コード例 #1
0
NS_IMETHODIMP ImportAddressImpl::GetSampleData(PRInt32 index, bool *pFound, PRUnichar **pStr)
{
  NS_PRECONDITION(pFound != nsnull, "null ptr");
  NS_PRECONDITION(pStr != nsnull, "null ptr");
  if (!pFound || !pStr)
    return NS_ERROR_NULL_POINTER;

  if (!m_fileLoc) {
    IMPORT_LOG0("*** Error, called GetSampleData before SetSampleLocation\n");
    return NS_ERROR_FAILURE;
  }

  nsresult rv;
  *pStr = nsnull;
  PRUnichar term = 0;

  if (!m_haveDelim) {
    rv = m_text.DetermineDelim(m_fileLoc);
    NS_ENSURE_SUCCESS(rv, rv);
    m_haveDelim = true;
    m_delim = m_text.GetDelim();
  }

  bool fileExists;
  rv = m_fileLoc->Exists(&fileExists);
  NS_ENSURE_SUCCESS(rv, rv);

  if (!fileExists) {
    *pFound = false;
    *pStr = NS_strdup(&term);
    return NS_OK;
  }

  nsCString line;
  rv = nsTextAddress::ReadRecordNumber(m_fileLoc, line, index);
  if (NS_SUCCEEDED(rv)) {
    nsString str;
    nsCString field;
    nsString uField;
    PRInt32 fNum = 0;
    while (nsTextAddress::GetField(line.get(), line.Length(), fNum, field, m_delim)) {
      if (fNum)
        str.Append(PRUnichar('\n'));
      SanitizeSampleData(field);
      rv = nsMsgI18NConvertToUnicode(nsMsgI18NFileSystemCharset(),
                                     field, uField);

      str.Append(uField);
      fNum++;
      field.Truncate();
    }

    *pStr = ToNewUnicode(str);
    *pFound = true;

    /* IMPORT_LOG1("Sample data: %S\n", str.get()); */
  }
  else {
    *pFound = false;
    *pStr = NS_strdup(&term);
  }

  return NS_OK;
}
コード例 #2
0
NS_IMETHODIMP
ImportAddressImpl::ImportAddressBook(nsIImportABDescriptor *pSource,
                                     nsIAddrDatabase *pDestination,
                                     nsIImportFieldMap *fieldMap,
                                     nsISupports *aSupportService,
                                     PRUnichar ** pErrorLog,
                                     PRUnichar ** pSuccessLog,
                                     bool * fatalError)
{
  NS_PRECONDITION(pSource != nsnull, "null ptr");
  NS_PRECONDITION(pDestination != nsnull, "null ptr");
  NS_PRECONDITION(fatalError != nsnull, "null ptr");

  m_bytesImported = 0;

  nsString success, error;
  if (!pSource || !pDestination || !fatalError) {
    IMPORT_LOG0("*** Bad param passed to text address import\n");
    nsImportStringBundle::GetStringByID(TEXTIMPORT_ADDRESS_BADPARAM,
                                        m_notProxyBundle,
                                        error);

    SetLogs(success, error, pErrorLog, pSuccessLog);

    if (fatalError)
      *fatalError = true;

    return NS_ERROR_NULL_POINTER;
  }

  ClearSampleFile();

  bool addrAbort = false;
  nsString name;
  pSource->GetPreferredName(name);

  PRUint32 addressSize = 0;
  pSource->GetSize(&addressSize);
  if (addressSize == 0) {
    IMPORT_LOG0("Address book size is 0, skipping import.\n");
    ReportSuccess(name, &success, m_notProxyBundle);
    SetLogs(success, error, pErrorLog, pSuccessLog);
    return NS_OK;
  }

  nsCOMPtr<nsIFile> inFile;
  if (NS_FAILED(pSource->GetAbFile(getter_AddRefs(inFile)))) {
    ReportError(TEXTIMPORT_ADDRESS_BADSOURCEFILE, name, &error, m_notProxyBundle);
    SetLogs(success, error, pErrorLog, pSuccessLog);
    return NS_ERROR_FAILURE;
  }

  if (!aSupportService) {
    IMPORT_LOG0("Missing support service to import call");
    return NS_ERROR_FAILURE;
  }

  bool isLDIF = false;
  nsresult rv;
  nsCOMPtr<nsIAbLDIFService> ldifService(do_QueryInterface(aSupportService, &rv));

    if (NS_SUCCEEDED(rv)) {
      rv = ldifService->IsLDIFFile(inFile, &isLDIF);
      if (NS_FAILED(rv)) {
        IMPORT_LOG0("*** Error reading address file\n");
      }
    }

  if (NS_FAILED(rv)) {
    ReportError(TEXTIMPORT_ADDRESS_CONVERTERROR, name, &error, m_notProxyBundle);
    SetLogs(success, error, pErrorLog, pSuccessLog);
    return rv;
  }

  if (isLDIF) {
    if (ldifService)
      rv = ldifService->ImportLDIFFile(pDestination, inFile, false, &m_bytesImported);
    else
      return NS_ERROR_FAILURE;
  }
  else {
    rv = m_text.ImportAddresses(&addrAbort, name.get(), inFile, pDestination, fieldMap, error, &m_bytesImported);
    SaveFieldMap(fieldMap);
  }

  if (NS_SUCCEEDED(rv) && error.IsEmpty()) {
    ReportSuccess(name, &success, m_notProxyBundle);
    SetLogs(success, error, pErrorLog, pSuccessLog);
  }
  else {
    ReportError(TEXTIMPORT_ADDRESS_CONVERTERROR, name, &error, m_notProxyBundle);
    SetLogs(success, error, pErrorLog, pSuccessLog);
  }

  IMPORT_LOG0("*** Text address import done\n");
  return rv;
}
コード例 #3
0
NS_IMETHODIMP ImportAddressImpl::FindAddressBooks(nsIFile *pLoc, nsISupportsArray **ppArray)
{
  NS_PRECONDITION(pLoc != nsnull, "null ptr");
  NS_PRECONDITION(ppArray != nsnull, "null ptr");
  if (!pLoc || !ppArray)
    return NS_ERROR_NULL_POINTER;

  ClearSampleFile();

  *ppArray = nsnull;
  bool exists = false;
  nsresult rv = pLoc->Exists(&exists);
  if (NS_FAILED(rv) || !exists)
    return NS_ERROR_FAILURE;

  bool isFile = false;
  rv = pLoc->IsFile(&isFile);
  if (NS_FAILED(rv) || !isFile)
    return NS_ERROR_FAILURE;

  rv = m_text.DetermineDelim(pLoc);

  if (NS_FAILED(rv)) {
    IMPORT_LOG0("*** Error determining delimitter\n");
    return rv;
  }
  m_haveDelim = true;
  m_delim = m_text.GetDelim();

  m_fileLoc = do_QueryInterface(pLoc);

  /* Build an address book descriptor based on the file passed in! */
  nsCOMPtr<nsISupportsArray> array;
  rv = NS_NewISupportsArray(getter_AddRefs(array));
  if (NS_FAILED(rv)) {
    IMPORT_LOG0("FAILED to allocate the nsISupportsArray\n");
    return rv;
  }

  nsString name;
  m_fileLoc->GetLeafName(name);
  if (NS_FAILED(rv)) {
    IMPORT_LOG0("*** Failed getting leaf name of file\n");
    return rv;
  }

  PRInt32 idx = name.RFindChar('.');
  if ((idx != -1) && (idx > 0) && ((name.Length() - idx - 1) < 5)) {
    name.SetLength(idx);
  }

  nsCOMPtr<nsIImportABDescriptor>  desc;
  nsISupports * pInterface;

  nsCOMPtr<nsIImportService> impSvc(do_GetService(NS_IMPORTSERVICE_CONTRACTID, &rv));
  if (NS_FAILED(rv)) {
    IMPORT_LOG0("*** Failed to obtain the import service\n");
    return rv;
  }

  rv = impSvc->CreateNewABDescriptor(getter_AddRefs(desc));
  if (NS_SUCCEEDED(rv)) {
    PRInt64 sz = 0;
    pLoc->GetFileSize(&sz);
    desc->SetPreferredName(name);
    desc->SetSize((PRUint32) sz);
    desc->SetAbFile(m_fileLoc);
    rv = desc->QueryInterface(kISupportsIID, (void **) &pInterface);
    array->AppendElement(pInterface);
    pInterface->Release();
  }
  if (NS_FAILED(rv)) {
    IMPORT_LOG0("*** Error creating address book descriptor for text import\n");
  }
  else {
    rv = array->QueryInterface(NS_GET_IID(nsISupportsArray), (void **) ppArray);
  }

  return rv;
}
コード例 #4
0
ファイル: nsTextImport.cpp プロジェクト: rn10950/RetroZilla
NS_IMETHODIMP ImportAddressImpl::GetSampleData( PRInt32 index, PRBool *pFound, PRUnichar **pStr)
{
    NS_PRECONDITION(pFound != nsnull, "null ptr");
    NS_PRECONDITION(pStr != nsnull, "null ptr");
    if (!pFound || !pStr)
        return( NS_ERROR_NULL_POINTER);

    if (!m_fileLoc) {
        IMPORT_LOG0( "*** Error, called GetSampleData before SetSampleLocation\n");
        return( NS_ERROR_FAILURE);
    }

    nsresult	rv;
    *pStr = nsnull;
    PRBool		open = PR_FALSE;
    PRUnichar	term = 0;

    if (!m_haveDelim) {
        rv = m_fileLoc->IsStreamOpen( &open);
        if (open) {
            m_fileLoc->CloseStream();
            open = PR_FALSE;
        }
        rv = m_text.DetermineDelim( m_fileLoc);
        if (NS_FAILED( rv))
            return( rv);
        m_haveDelim = PR_TRUE;
        m_delim = m_text.GetDelim();
    }
    else {
        rv = m_fileLoc->IsStreamOpen( &open);
    }

    if (!open) {
        rv = m_fileLoc->OpenStreamForReading();
        if (NS_FAILED( rv)) {
            *pFound = PR_FALSE;
            *pStr = nsCRT::strdup( &term);
            return( NS_OK);
        }
    }

    PRInt32	lineLen;
    PRInt32	bufSz = 10240;
    char	*pLine = new char[bufSz];

    nsCOMPtr<nsIImportService> impSvc(do_GetService(NS_IMPORTSERVICE_CONTRACTID, &rv));

    rv = nsTextAddress::ReadRecordNumber( m_fileLoc, pLine, bufSz, m_delim, &lineLen, index);
    if (NS_SUCCEEDED( rv)) {
        nsString	str;
        nsCString	field;
        nsString	uField;
        PRInt32		fNum = 0;
        while (nsTextAddress::GetField( pLine, lineLen, fNum, field, m_delim)) {
            if (fNum)
                str.AppendLiteral("\n");
            SanitizeSampleData( field);
            if (impSvc)
                impSvc->SystemStringToUnicode( field.get(), uField);
            else
                uField.AssignWithConversion( field.get());

            str.Append( uField);
            fNum++;
            field.Truncate();
        }

        *pStr = nsCRT::strdup( str.get());
        *pFound = PR_TRUE;

        /* IMPORT_LOG1( "Sample data: %S\n", str.get()); */
    }
    else {
        *pFound = PR_FALSE;
        *pStr = nsCRT::strdup( &term);
    }

    delete [] pLine;

    return( NS_OK);
}
コード例 #5
0
ファイル: nsTextImport.cpp プロジェクト: rn10950/RetroZilla
NS_IMETHODIMP ImportAddressImpl::ImportAddressBook(	nsIImportABDescriptor *pSource,
        nsIAddrDatabase *	pDestination,
        nsIImportFieldMap *	fieldMap,
        PRBool isAddrLocHome,
        PRUnichar **		pErrorLog,
        PRUnichar **		pSuccessLog,
        PRBool *			fatalError)
{
    NS_PRECONDITION(pSource != nsnull, "null ptr");
    NS_PRECONDITION(pDestination != nsnull, "null ptr");
    NS_PRECONDITION(fatalError != nsnull, "null ptr");

    nsCOMPtr<nsIStringBundle>	bundle( dont_AddRef( nsTextStringBundle::GetStringBundleProxy()));
    m_bytesImported = 0;

    nsString	success;
    nsString	error;
    if (!pSource || !pDestination || !fatalError) {
        IMPORT_LOG0( "*** Bad param passed to text address import\n");
        nsTextStringBundle::GetStringByID( TEXTIMPORT_ADDRESS_BADPARAM, error, bundle);
        if (fatalError)
            *fatalError = PR_TRUE;
        SetLogs( success, error, pErrorLog, pSuccessLog);
        return( NS_ERROR_NULL_POINTER);
    }

    ClearSampleFile();

    PRBool		addrAbort = PR_FALSE;
    nsString	name;
    PRUnichar *	pName;
    if (NS_SUCCEEDED( pSource->GetPreferredName( &pName))) {
        name = pName;
        nsCRT::free( pName);
    }

    PRUint32 addressSize = 0;
    pSource->GetSize( &addressSize);
    if (addressSize == 0) {
        IMPORT_LOG0( "Address book size is 0, skipping import.\n");
        ReportSuccess( name, &success);
        SetLogs( success, error, pErrorLog, pSuccessLog);
        return( NS_OK);
    }


    nsIFileSpec	*	inFile;
    if (NS_FAILED( pSource->GetFileSpec( &inFile))) {
        ReportError( TEXTIMPORT_ADDRESS_BADSOURCEFILE, name, &error);
        SetLogs( success, error, pErrorLog, pSuccessLog);
        return( NS_ERROR_FAILURE);
    }

    nsXPIDLCString pPath;
    inFile->GetNativePath(getter_Copies(pPath));
    IMPORT_LOG1( "Importing address book: %s\n", pPath.get());

    nsresult rv = NS_OK;
    PRBool	isLDIF = PR_FALSE;

    nsCOMPtr<nsIAbLDIFService> ldifService = do_GetService(NS_ABLDIFSERVICE_CONTRACTID, &rv);

    if (NS_SUCCEEDED(rv)) {
        rv = ldifService->IsLDIFFile(inFile, &isLDIF);
        if (NS_FAILED(rv)) {
            IMPORT_LOG0( "*** Error reading address file\n");
        }
    }

    if (NS_FAILED( rv)) {
        inFile->Release();
        ReportError( TEXTIMPORT_ADDRESS_CONVERTERROR, name, &error);
        SetLogs( success, error, pErrorLog, pSuccessLog);
        return( rv);
    }

    if (isLDIF) {
        if (ldifService)
            rv = ldifService->ImportLDIFFile(pDestination, inFile, PR_FALSE, &m_bytesImported);
        else
            return NS_ERROR_FAILURE;
    }
    else {
        rv = m_text.ImportAddresses( &addrAbort, name.get(), inFile, pDestination, fieldMap, error, &m_bytesImported);
        SaveFieldMap( fieldMap);
    }

    inFile->Release();


    if (NS_SUCCEEDED( rv) && error.IsEmpty()) {
        ReportSuccess( name, &success);
    }
    else {
        ReportError( TEXTIMPORT_ADDRESS_CONVERTERROR, name, &error);
    }

    SetLogs( success, error, pErrorLog, pSuccessLog);

    IMPORT_LOG0( "*** Text address import done\n");
    return rv;
}
コード例 #6
0
ファイル: nsTextImport.cpp プロジェクト: rn10950/RetroZilla
NS_IMETHODIMP ImportAddressImpl::FindAddressBooks(nsIFileSpec *pLoc, nsISupportsArray **ppArray)
{
    NS_PRECONDITION(pLoc != nsnull, "null ptr");
    NS_PRECONDITION(ppArray != nsnull, "null ptr");
    if (!pLoc || !ppArray)
        return NS_ERROR_NULL_POINTER;

    ClearSampleFile();

    *ppArray = nsnull;
    PRBool exists = PR_FALSE;
    nsresult rv = pLoc->Exists( &exists);
    if (NS_FAILED( rv) || !exists)
        return( NS_ERROR_FAILURE);

    PRBool isFile = PR_FALSE;
    rv = pLoc->IsFile( &isFile);
    if (NS_FAILED( rv) || !isFile)
        return( NS_ERROR_FAILURE);

    rv = m_text.DetermineDelim( pLoc);

    if (NS_FAILED( rv)) {
        IMPORT_LOG0( "*** Error determining delimitter\n");
        return( rv);
    }
    m_haveDelim = PR_TRUE;
    m_delim = m_text.GetDelim();

    m_fileLoc = pLoc;
    NS_ADDREF( m_fileLoc);

    /* Build an address book descriptor based on the file passed in! */
    nsCOMPtr<nsISupportsArray>	array;
    rv = NS_NewISupportsArray( getter_AddRefs( array));
    if (NS_FAILED( rv)) {
        IMPORT_LOG0( "FAILED to allocate the nsISupportsArray\n");
        return( rv);
    }

    nsCOMPtr<nsIImportService> impSvc(do_GetService(NS_IMPORTSERVICE_CONTRACTID, &rv));
    if (NS_FAILED( rv)) {
        IMPORT_LOG0( "*** Failed to obtain the import service\n");
        return( rv);
    }

    nsXPIDLCString pName;
    rv = pLoc->GetLeafName(getter_Copies(pName));
    if (NS_FAILED( rv)) {
        IMPORT_LOG0( "*** Failed getting leaf name of file\n");
        return( rv);
    }

    // for get unicode leafname.  If it uses nsILocalFile interface,
    // these codes do not need due to nsILocalFile->GetUnicodeLeafName()
    nsString	name;
    rv = impSvc->SystemStringToUnicode((const char*) pName, name);
    if (NS_FAILED(rv))
        name.AssignWithConversion((const char*) pName);

    PRInt32		idx = name.RFindChar( '.');
    if ((idx != -1) && (idx > 0) && ((name.Length() - idx - 1) < 5)) {
        nsString t;
        name.Left( t, idx);
        name = t;
    }

    nsCOMPtr<nsIImportABDescriptor>	desc;
    nsISupports *					pInterface;

    rv = impSvc->CreateNewABDescriptor( getter_AddRefs( desc));
    if (NS_SUCCEEDED( rv)) {
        PRUint32 sz = 0;
        pLoc->GetFileSize( &sz);
        desc->SetPreferredName( name.get());
        desc->SetSize( sz);
        nsIFileSpec *pSpec = nsnull;
        desc->GetFileSpec( &pSpec);
        if (pSpec) {
            pSpec->FromFileSpec( pLoc);
            NS_RELEASE( pSpec);
        }
        rv = desc->QueryInterface( kISupportsIID, (void **) &pInterface);
        array->AppendElement( pInterface);
        pInterface->Release();
    }
    if (NS_FAILED( rv)) {
        IMPORT_LOG0( "*** Error creating address book descriptor for text import\n");
    }
    else {
        rv = array->QueryInterface( NS_GET_IID(nsISupportsArray), (void **) ppArray);
    }

    return( rv);
}