taskbuilder.cpp

funambol windows mobile plugin source code, the source code is taken from the funambol site

    dummyEvent=NULL;

    dummyEvent = getElementContent(ptrData, TEXT ("Complete"), NULL);
    if (dummyEvent != NULL &&
        (wcscmp(dummyEvent, TEXT("1")) == 0 ||
         wcscmp(dummyEvent, TEXT("-1")) == 0 ||
         wcscmp(dummyEvent, TEXT("True")) == 0)) {
        pTask->put_Complete(VARIANT_TRUE);
    }
    else {
        pTask->put_Complete(VARIANT_FALSE);
    }

    if (dummyEvent != NULL)
        delete [] dummyEvent;dummyEvent=NULL;

    dummyEvent = getElementContent(ptrData, TEXT ("TeamTask"), NULL);
    if (dummyEvent != NULL &&
        (wcscmp(dummyEvent, TEXT("1")) == 0 ||
         wcscmp(dummyEvent, TEXT("-1")) == 0 ||
         wcscmp(dummyEvent, TEXT("True")) == 0)) {
        pTask->put_TeamTask(VARIANT_TRUE);
    }
    else {
        pTask->put_TeamTask(VARIANT_FALSE);
    }
    if (dummyEvent != NULL)
        delete [] dummyEvent; dummyEvent=NULL;


    // BSTR
    dummyEvent = getElementContent(ptrData, TEXT ("Subject"), NULL);
    if (dummyEvent != NULL) {
        dummyEvent_s = wstring(dummyEvent); decodeSpecialChar(dummyEvent_s);
        convertNewlines(dummyEvent_s);
        pTask->put_Subject ((wchar_t*)dummyEvent_s.data());
        delete [] dummyEvent;  dummyEvent=NULL;
    }

    dummyEvent = getElementContent(ptrData, TEXT ("Categories"), NULL);
    if (dummyEvent != NULL) {
        dummyEvent_s = wstring(dummyEvent); decodeSpecialChar(dummyEvent_s);
        pTask->put_Categories ((wchar_t*)dummyEvent_s.data());
        delete [] dummyEvent; dummyEvent=NULL;
    }

    dummyEvent = getElementContent(ptrData, TEXT ("ReminderSoundFile"), NULL);
    if (dummyEvent != NULL) {
        dummyEvent_s = wstring(dummyEvent); decodeSpecialChar(dummyEvent_s);
        pTask->put_ReminderSoundFile  ((wchar_t*)dummyEvent_s.data());
        delete [] dummyEvent; dummyEvent=NULL;
    }

    dummyEvent = getElementContent(ptrData, TEXT ("Body"), NULL);
    if (dummyEvent != NULL) {
        dummyEvent_s = wstring(dummyEvent); decodeSpecialChar(dummyEvent_s);
        convertNewlines(dummyEvent_s);
        pTask->put_Body  ((wchar_t*)dummyEvent_s.data());
        delete [] dummyEvent;  dummyEvent=NULL;
    }

    // This value is passed to parseRecurrenceTags if the task is recurrent
    // can be StartDate, or DueDate if StartDate is not set.
    DATE recurrenceStart = 0;

    dummyEvent = getElementContent(ptrData, TEXT ("StartDate"), NULL);
    if (dummyEvent != NULL && (wcscmp(dummyEvent, TEXT("")) != 0)) {
        recurrenceStart = getDATEFromString(dummyEvent);
        pTask->put_StartDate(recurrenceStart);
        delete [] dummyEvent;

    }

    dummyEvent = getElementContent(ptrData, TEXT ("DueDate"), NULL);
    if (dummyEvent != NULL && (wcscmp(dummyEvent, TEXT("")) != 0)) {
        DATE dd;
        systemTimeToDoubleBirthday(dummyEvent, &dd);
        //wsprintf(localTemp, TEXT("%f"), dd);   DEBUG?
        if(!recurrenceStart) {
            recurrenceStart = dd;
        }
        pTask->put_DueDate(dd);
        delete [] dummyEvent;

    }
    if (dummyEvent) { delete [] dummyEvent; dummyEvent = NULL; }

    //long
    dummyEvent = getElementContent(ptrData, TEXT ("Importance"), NULL);
    if (dummyEvent != NULL) {
        pTask->put_Importance(wcstol(dummyEvent, &dummy, 0));
        delete [] dummyEvent; dummyEvent=NULL;
    }

    dummyEvent = getElementContent(ptrData, TEXT ("Sensitivity"), NULL);
    if (dummyEvent != NULL) {
        pTask->put_Sensitivity(wcstol(dummyEvent, &dummy, 0));
        delete [] dummyEvent; dummyEvent=NULL;
    }

    dummyEvent = getElementContent(ptrData, TEXT ("ReminderOptions"), NULL);
    if (dummyEvent != NULL) {
        pTask->put_ReminderOptions (wcstol(dummyEvent, &dummy, 0));
        delete [] dummyEvent; dummyEvent=NULL;
    }

    /****************************************************/

    //Recurrence
    dummyEvent = getElementContent(ptrData, TEXT ("IsRecurring"), NULL);

    if (dummyEvent != NULL && (wcscmp(dummyEvent, TEXT("1")) == 0 ||
                               wcscmp(dummyEvent, TEXT("-1")) == 0 ||
                               wcscmp(dummyEvent, TEXT("True")) == 0)) {

        pTask->ClearRecurrencePattern();

        IRecurrencePattern *pRecurrence;
        pTask->GetRecurrencePattern (&pRecurrence);

        // Parse the recurrence tags
        parseRecurrenceTags(pRecurrence, ptrData, recurrenceStart, 0, 0);

        pRecurrence->Release();
    }
}

/*
* The method calculate the CRC hash value for the task item.
* It create the XML structure and calculate the crc value.
* Use to compare for understand the modified value!
*
* @param pTask : the task object that contain every value
*/

long calculateTaskHash (ITask *pTask) {

    wstring p ;

    populateTaskStringItem(p, pTask, TRUE);
    long l = stringCrc32(p.data());

    return l;
}

VObject* TaskToVObject(ITask *pTask) {
    VObject* vo = new VObject();
    VProperty* vp      = NULL;

    wchar_t* dateValue;
    DATE startdate;
    DATE duedate;
    DATE completeddate;
    BSTR element;

    vp = new VProperty(TEXT("BEGIN"), TEXT("VCALENDAR"));
    vo->addProperty(vp);
    delete vp; vp = NULL;

    vp = new VProperty(TEXT("BEGIN"), TEXT("VTODO"));
    vo->addProperty(vp);
    delete vp; vp = NULL;


    pTask->get_Subject(&element);
    if(wcscmp(element, TEXT(""))) {
        vp = new VProperty(TEXT("SUMMARY"), element);
        vo->addProperty(vp);
        delete vp; vp = NULL;
    }

    pTask->get_Body(&element);
     if(wcscmp(element, TEXT(""))) {
        vp = new VProperty(TEXT("DESCRIPTION"), element);
        vo->addProperty(vp);
        delete vp; vp = NULL;
    }

    pTask->get_StartDate(&startdate);
    dateValue = new wchar_t[20];
    doubleToSystemTime(dateValue, startdate);
    vp = new VProperty(TEXT("DTSTART"), dateValue);
    vo->addProperty(vp);
    delete vp; vp = NULL;
    delete [] dateValue; dateValue = NULL;

    pTask->get_DueDate(&duedate);
    dateValue = new wchar_t[20];
    doubleToSystemTime(dateValue, duedate);
    vp = new VProperty(TEXT("DUE"), dateValue);
    vo->addProperty(vp);
    delete vp; vp = NULL;
    delete [] dateValue; dateValue = NULL;

    VARIANT_BOOL completed;
    pTask->get_Complete(&completed);

    if(completed) {
        pTask->get_DateCompleted(&completeddate);
        dateValue = new wchar_t[20];
        doubleToSystemTime(dateValue, completeddate);
        vp = new VProperty(TEXT("COMPLETED"), dateValue);
        vo->addProperty(vp);
        delete vp; vp = NULL;
        delete [] dateValue; dateValue = NULL;
    }

    pTask->get_Categories(&element);
    if(wcscmp(element, TEXT(""))) {
        vp = new VProperty(TEXT("CATEGORIES"), element);
        vo->addProperty(vp);
        delete vp; vp = NULL;
    }


    long sensitivity;
    pTask->get_Sensitivity(&sensitivity);
    vp = new VProperty(TEXT("CLASS"));
    if(sensitivity == olPrivate)
        vp->addValue(TEXT("PRIVATE"));
    else
        vp->addValue(TEXT("PUBLIC"));
    vo->addProperty(vp);
    delete vp; vp = NULL;


    VARIANT_BOOL bReminder;
    pTask->get_ReminderSet(&bReminder);

    if(bReminder == VARIANT_TRUE) {
        DATE reminder;
        dateValue = new wchar_t[20];

        pTask->get_ReminderTime(&reminder);

        doubleToSystemTime(dateValue, reminder);

        vp = new VProperty(TEXT("AALARM"));
        vp->addValue(dateValue);                        // "RunTime"
        vp->addValue(TEXT(""));                         // "Snooze Time" (empty)
        vp->addValue(TEXT("0"));                        // "Repeat Count"
        vp->addValue(TEXT("reminder"));                 // "Audio Content"
        vo->addProperty(vp);

        delete vp; vp = NULL;
        delete [] dateValue; dateValue = NULL;
    }


    long importance;
    pTask->get_Importance(&importance);
    vp = new VProperty(TEXT("PRIORITY"));
    if(importance == olImportanceLow)
        vp->addValue(TEXT("3"));
    else if(importance == olImportanceNormal)
        vp->addValue(TEXT("2"));
    else if(importance == olImportanceHigh)
        vp->addValue(TEXT("1"));
    vo->addProperty(vp);
    delete vp; vp = NULL;


    VARIANT_BOOL isRec;
    pTask->get_IsRecurring(&isRec);

    if(isRec == VARIANT_TRUE) {
        IRecurrencePattern* pRecPat;
        pTask->GetRecurrencePattern(& pRecPat);
        wchar_t* recRule = NULL;
        recRule = extractRrule(pRecPat);
        if(recRule) {
            vp = new VProperty(TEXT("RRULE"), recRule);
            vo->addProperty(vp);
            delete vp;         vp      = NULL;
            delete [] recRule; recRule = NULL;

        }
        pRecPat->Release();
    }

    vp = new VProperty(TEXT("END"), TEXT("VTODO"));
    vo->addProperty(vp);
    delete vp; vp = NULL;

    vp = new VProperty(TEXT("END"), TEXT("VCALENDAR"));
    vo->addProperty(vp);
    delete vp; vp = NULL;

    return vo;
}


void VObjectToTask(ITask *pTask, VObject *vo) {

    int i = 0;

    pTask->ClearRecurrencePattern ();

    if(vo->containsProperty(TEXT("SUMMARY")) && vo->getProperty(TEXT("SUMMARY"))->getValue())
        pTask->put_Subject(vo->getProperty(TEXT("SUMMARY"))->getValue());

    if(vo->containsProperty(TEXT("DESCRIPTION")) && vo->getProperty(TEXT("DESCRIPTION"))->getValue())
        pTask->put_Body(vo->getProperty(TEXT("DESCRIPTION"))->getValue());

    DATE startdate = NULL;
    DATE duedate = NULL;

    if(vo->containsProperty(TEXT("DTSTART")) && vo->getProperty(TEXT("DTSTART"))->getValue()) {

        systemTimeToDouble(vo->getProperty(TEXT("DTSTART"))->getValue(), &startdate, NULL);
        pTask->put_StartDate(startdate);
        }

    if(vo->containsProperty(TEXT("DUE")) && vo->getProperty(TEXT("DUE"))->getValue()) {

        systemTimeToDouble(vo->getProperty(TEXT("DUE"))->getValue(), &duedate, NULL);
        pTask->put_DueDate(duedate);
        }

    if(vo->containsProperty(TEXT("CATEGORIES")) && vo->getProperty(TEXT("CATEGORIES"))->getValue())
        pTask->put_Categories(vo->getProperty(TEXT("CATEGORIES"))->getValue());


    if(vo->containsProperty(TEXT("CLASS")) && vo->getProperty(TEXT("CLASS"))->getValue()) {
        wchar_t* calClass = new wchar_t[20];
        wcscpy(calClass, vo->getProperty(TEXT("CLASS"))->getValue());
        if(!wcscmp(calClass, TEXT("PRIVATE")) || !wcscmp(calClass, TEXT("CONFIDENTIAL")))
            pTask->put_Sensitivity(olPrivate);
        else
            pTask->put_Sensitivity(olNormal);

        delete [] calClass;
    }
    else
        pTask->put_Sensitivity(olNormal);

    //alarm
    //The value consists of: Run Time, Snooze Time; Repeat Count, Audio Content
    if(vo->containsProperty(TEXT("AALARM")) && vo->getProperty(TEXT("AALARM"))->getValue()) {

        DATE runTime;
        systemTimeToDouble(vo->getProperty(TEXT("AALARM"))->getPropComponent(1), &runTime, NULL);

        pTask->put_ReminderSet(VARIANT_TRUE);
        pTask->put_ReminderTime(runTime);

    }

    if(vo->containsProperty(TEXT("COMPLETED")) && vo->getProperty(TEXT("COMPLETED"))->getValue()) {
        pTask->put_Complete(VARIANT_TRUE);
    }

    if(vo->containsProperty(TEXT("PRIORITY")) && vo->getProperty(TEXT("PRIORITY"))->getValue()) {
        wchar_t* prior = vo->getProperty(TEXT("PRIORITY"))->getValue();
        long importance;

        if(!wcscmp(prior, TEXT("1")))
            importance = olImportanceHigh;
        else if(!wcscmp(prior, TEXT("2")))
            importance = olImportanceNormal;
        else if(!wcscmp(prior, TEXT("3")))
            importance = olImportanceLow;
    }

    //recurrence
    if((vo->containsProperty(TEXT("RRULE")) && vo->getProperty(TEXT("RRULE"))->getValue())) {

        pTask->ClearRecurrencePattern();

        IRecurrencePattern* pRecPat;
        pTask->GetRecurrencePattern(& pRecPat);


        DATE startDate;
        pTask->get_StartDate(&startDate);
        bool ret = convertRrule(pRecPat, vo->getProperty(TEXT("RRULE"))->getValue(), startDate);

        if(!ret)
            pTask->ClearRecurrencePattern();

        pRecPat->Release();

    }

}