1 /*

     2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Provides access to versit parser propertys iArrayOfParams*

    15 */

    16 

    17 

    18 // CLASS HEADER

    19 #include "cpimparserproperty.h"

    20 

    21 // INTERNAL INCLUDES

    22 #include "pimcommon.h"

    23 #include "pimcontact.h"

    24 #include "pimevent.h"

    25 #include "pimtodo.h"

    26 #include "pimversit.h"

    27 #include "logger.h"

    28 

    29 // EXTERNAL INCLUDES

    30 #include <cntdef.h>

    31 

    32 // ============================ MEMBER FUNCTIONS ===============================

    33 

    34 // ---------------------------------------------------------------------------

    35 // CPIMParserProperty::ArrayOfParams

    36 // ---------------------------------------------------------------------------

    37 //

    38 const CArrayPtr<CParserParam>* CPIMParserProperty::ArrayOfParams() const

    39 {

    40     JELOG2(EPim);

    41     return iArrayOfParams;

    42 }

    43 

    44 // ---------------------------------------------------------------------------

    45 // CPIMParserProperty::MatchAllAttributes

    46 // ---------------------------------------------------------------------------

    47 //

    48 TPIMAttribute CPIMParserProperty::MatchAllAttributes() const

    49 {

    50     JELOG2(EPim);

    51     TPIMAttribute attributes = KPIMAttrNone;

    52     if (!iArrayOfParams)

    53     {

    54         // No attributes

    55         return attributes;

    56     }

    57     // Iterate through all attributes

    58     TInt paramCount = iArrayOfParams->Count();

    59     for (TInt i = 0; i < paramCount; i++)

    60     {

    61         const CParserParam& param = *(iArrayOfParams->At(i));

    62         // The value may be stored as a name or a value in the parser

    63         if (DoCompareNameAndValue(param, KVersitParam8Pref))

    64         {

    65             attributes |= EPIMContactAttrPreferred;

    66         }

    67         if (DoCompareNameAndValue(param, KVersitParam8Pager))

    68         {

    69             attributes |= EPIMContactAttrPager;

    70         }

    71         if (DoCompareNameAndValue(param, KVersitParam8Cell))

    72         {

    73             attributes |= EPIMContactAttrMobile;

    74         }

    75         if (DoCompareNameAndValue(param, KVersitParam8Fax))

    76         {

    77             attributes |= EPIMContactAttrFax;

    78         }

    79         if (DoCompareNameAndValue(param, KVersitParam8Home))

    80         {

    81             attributes |= EPIMContactAttrHome;

    82         }

    83         if (DoCompareNameAndValue(param, KVersitParam8Work))

    84         {

    85             attributes |= EPIMContactAttrWork;

    86         }

    87         if (DoCompareNameAndValue(param, KVersitParam8Car))

    88         {

    89             attributes |= EPIMContactAttrAuto;

    90         }

    91         if (DoCompareNameAndValue(param, KVersitParam8Video))

    92         {

    93             attributes |= EPIMContactAttrExtVideoCall;

    94         }

    95         if (DoCompareNameAndValue(param, KPIMVersitTokenASSTTEL))

    96         {

    97             attributes |= EPIMContactAttrAsst;

    98         }

    99     }

   100 

   101     return attributes;

   102 }

   103 

   104 // ---------------------------------------------------------------------------

   105 // CPIMParserProperty::MatchHomeAndWorkAttributes

   106 // ---------------------------------------------------------------------------

   107 //

   108 TPIMAttribute CPIMParserProperty::MatchHomeAndWorkAttributes() const

   109 {

   110     JELOG2(EPim);

   111     TPIMAttribute attributes = KPIMAttrNone;

   112     if (!iArrayOfParams)

   113     {

   114         // No attributes

   115         return attributes;

   116     }

   117     // Iterate through all attributes

   118     TInt paramCount = iArrayOfParams->Count();

   119     for (TInt i = 0; i < paramCount; i++)

   120     {

   121         const CParserParam& param = *(iArrayOfParams->At(i));

   122         // The value may be stored as a name or a value in the parser

   123         if (DoCompareNameAndValue(param, KVersitParam8Home))

   124         {

   125             attributes |= EPIMContactAttrHome;

   126         }

   127         if (DoCompareNameAndValue(param, KVersitParam8Work))

   128         {

   129             attributes |= EPIMContactAttrWork;

   130         }

   131     }

   132 

   133     return attributes;

   134 }

   135 

   136 // ---------------------------------------------------------------------------

   137 // CPIMParserProperty::ContainsParameter

   138 // ---------------------------------------------------------------------------

   139 //

   140 TBool CPIMParserProperty::ContainsParameter(const TDesC8& aParam) const

   141 {

   142     JELOG2(EPim);

   143     if (!iArrayOfParams)

   144     {

   145         return EFalse;

   146     }

   147     // Iterate through all attributes

   148     TInt paramCount = iArrayOfParams->Count();

   149     for (TInt i = 0; i < paramCount; i++)

   150     {

   151         const CParserParam& param = *(iArrayOfParams->At(i));

   152         // The value may be stored as a name or a value in the parser

   153         if (DoCompareNameAndValue(param, aParam))

   154         {

   155             return ETrue;

   156         }

   157     }

   158     return EFalse;

   159 }

   160 

   161 // ---------------------------------------------------------------------------

   162 // CPIMParserProperty::MatchContactField

   163 // ---------------------------------------------------------------------------

   164 //

   165 TPIMField CPIMParserProperty::MatchContactField() const

   166 {

   167     JELOG2(EPim);

   168     TPIMField field = KErrNotFound;

   169     TPtrC8 name = Name();

   170     if (name.CompareF(KVersitTokenADR) == 0)

   171     {

   172         field = EPIMContactAddr;

   173     }

   174     else if (name.CompareF(KVersitTokenN) == 0)

   175     {

   176         field = EPIMContactName;

   177     }

   178     else if (name.CompareF(KVersitTokenORG) == 0)

   179     {

   180         field = EPIMContactOrg;

   181     }

   182     else if (name.CompareF(KVersitTokenChildren) == 0)

   183     {

   184         field = EPIMContactExtChildren;

   185     }

   186     else if (name.CompareF(KVersitTokenBDAY) == 0)

   187     {

   188         field = EPIMContactBirthday;

   189     }

   190     else if (name.CompareF(KVersitTokenREV) == 0)

   191     {

   192         field = EPIMContactRevision;

   193     }

   194     else if (name.CompareF(KVersitTokenAnniversary) == 0)

   195     {

   196         field = EPIMContactExtAnniversary;

   197     }

   198     else if (name.CompareF(KVersitTokenEMAIL) == 0)

   199     {

   200         field = EPIMContactEmail;

   201     }

   202     else if (name.CompareF(KVersitTokenNOTE) == 0)

   203     {

   204         field = EPIMContactNote;

   205     }

   206     else if (name.CompareF(KVersitTokenTEL) == 0 || name.CompareF(

   207                  KPIMVersitTokenASSTTEL) == 0)

   208     {

   209         field = EPIMContactTel;

   210     }

   211     else if (name.CompareF(KVersitTokenTITLE) == 0)

   212     {

   213         field = EPIMContactTitle;

   214     }

   215     else if (name.CompareF(KVersitTokenURL) == 0)

   216     {

   217         field = EPIMContactUrl;

   218     }

   219     else if (name.CompareF(KPIMVersitTokenNICKNAME) == 0)

   220     {

   221         field = EPIMContactNickname;

   222     }

   223     else if (name.CompareF(KPIMVersitTokenDTMF) == 0)

   224     {

   225         field = EPIMContactExtDtmf;

   226     }

   227     else if (name.CompareF(KPIMVersitTokenWVID) == 0)

   228     {

   229         field = EPIMContactExtWvUserId;

   230     }

   231     else if (name.CompareF(KVersitTokenAssistant) == 0)

   232     {

   233         field = EPIMContactExtAssistantName;

   234     }

   235     else if (name.CompareF(KVersitTokenChildren) == 0)

   236     {

   237         field = EPIMContactExtChildren;

   238     }

   239     else if (name.CompareF(KVersitTokenSpouse) == 0)

   240     {

   241         field = EPIMContactExtSpouse;

   242     }

   243     else if (name.CompareF(KPIMVersitTokenSIP) == 0)

   244     {

   245         // Check that if this is VOIP field

   246         if (ContainsParameter(KPIMVersitTokenVoip))

   247         {

   248             field = EPIMContactExtVoip;

   249         }

   250         // Check that if this is POC field

   251         else if (ContainsParameter(KPIMVersitTokenPoc))

   252         {

   253             field = EPIMContactExtPTT;

   254         }

   255         // Check that if this is SWIS field

   256         else if (ContainsParameter(KPIMVersitTokenSwis))

   257         {

   258             field = EPIMContactExtSWIS;

   259         }

   260         else

   261         {

   262             field = EPIMContactExtSip;

   263         }

   264     }

   265     else if (name.CompareF(KVersitTokenUID) == 0)

   266     {

   267         field = EPIMContactUid;

   268     }

   269     return field;

   270 }

   271 

   272 // ---------------------------------------------------------------------------

   273 // CPIMParserProperty::MatchContactField

   274 // ---------------------------------------------------------------------------

   275 //

   276 TPIMField CPIMParserProperty::MatchEventField() const

   277 {

   278     JELOG2(EPim);

   279     TPIMField field = KErrNotFound;

   280     TPtrC8 name = Name();

   281     if (name.CompareF(KVersitTokenDTSTART) == 0)

   282     {

   283         field = EPIMEventStart;

   284     }

   285     else if (name.CompareF(KVersitTokenDTEND) == 0)

   286     {

   287         field = EPIMEventEnd;

   288     }

   289     else if (name.CompareF(KVersitTokenLASTMODIFIED) == 0)

   290     {

   291         field = EPIMEventRevision;

   292     }

   293     else if (name.CompareF(KVersitTokenSUMMARY) == 0)

   294     {

   295         field = EPIMEventSummary;

   296     }

   297     else if (name.CompareF(KVersitTokenDESCRIPTION) == 0)

   298     {

   299         field = EPIMEventNote;

   300     }

   301     else if (name.CompareF(KVersitTokenLOCATION) == 0)

   302     {

   303         field = EPIMEventLocation;

   304     }

   305     else if (name.CompareF(KVersitTokenDALARM) == 0)

   306     {

   307         field = EPIMEventAlarm;

   308     }

   309     else if (name.CompareF(KVersitTokenUID) == 0)

   310     {

   311         field = EPIMEventUid;

   312     }

   313     return field;

   314 }

   315 

   316 // ---------------------------------------------------------------------------

   317 // CPIMParserProperty::MatchContactField

   318 // ---------------------------------------------------------------------------

   319 //

   320 TPIMField CPIMParserProperty::MatchToDoField() const

   321 {

   322     JELOG2(EPim);

   323     TPIMField field = KErrNotFound;

   324     TPtrC8 name = Name();

   325 

   326     if (name.CompareF(KVersitTokenDUE) == 0)

   327     {

   328         field = EPIMToDoDue;

   329     }

   330     else if (name.CompareF(KVersitTokenCOMPLETED) == 0)

   331     {

   332         field = EPIMToDoCompletionDate;

   333     }

   334     else if (name.CompareF(KVersitTokenLASTMODIFIED) == 0)

   335     {

   336         field = EPIMToDoRevision;

   337     }

   338     else if (name.CompareF(KVersitTokenSUMMARY) == 0)

   339     {

   340         field = EPIMToDoSummary;

   341     }

   342     else if (name.CompareF(KVersitTokenDESCRIPTION) == 0)

   343     {

   344         field = EPIMToDoNote;

   345     }

   346     else if (name.CompareF(KVersitTokenPRIORITY) == 0)

   347     {

   348         field = EPIMToDoPriority;

   349     }

   350     else if (name.CompareF(KVersitTokenDALARM) == 0)

   351     {

   352         field = EPIMToDoExtAlarm;

   353     }

   354     else if (name.CompareF(KVersitTokenSTATUS) == 0)

   355     {

   356         field = EPIMToDoCompleted;

   357     }

   358     else if (name.CompareF(KVersitTokenUID) == 0)

   359     {

   360         field = EPIMToDoUid;

   361     }

   362     return field;

   363 }

   364 

   365 // ---------------------------------------------------------------------------

   366 // CPIMParserProperty::DoCompareNameAndValue

   367 // ---------------------------------------------------------------------------

   368 //

   369 TBool CPIMParserProperty::DoCompareNameAndValue(const CParserParam& aParam,

   370         const TDesC8& aValue) const

   371 {

   372     JELOG2(EPim);

   373     if ((aParam.Name().CompareF(aValue) == 0) || (aParam.Value().CompareF(

   374                 aValue) == 0))

   375     {

   376         return ETrue;

   377     }

   378 

   379     return EFalse;

   380 }

   381 

   382 //  End of File