void DateTimeTextMatchPlugin::lookForDateRanges( const QRegExp& regExp, const QString& format, int dateCap, int rangeEndCap, int yearCap, bool forceCurrentYear )
{
// kDebug() << regExp.pattern() << format;
int pos = 0;
while ( ( pos = regExp.indexIn( m_text, pos ) ) != -1 ) {
QDate startDate = m_enLocale.toDate( regExp.cap( dateCap ), format );
if ( startDate.isValid() ) {
if ( yearCap > 0 && regExp.cap( yearCap ).length() ) {
startDate = QDate( regExp.cap( yearCap ).toInt(), startDate.month(), startDate.day() );
}
else if ( forceCurrentYear ) {
startDate = QDate( QDate::currentDate().year(), startDate.month(), startDate.day() );
}
kDebug() << regExp.cap( dateCap ) << regExp.cap( rangeEndCap );
QDate endDate( startDate.year(), startDate.month(), regExp.cap( rangeEndCap ).toInt() );
kDebug() << "Found date range" << startDate << endDate;
m_dateRanges.insert( pos, qMakePair( qMakePair( startDate, endDate ), regExp.matchedLength() ) );
}
else {
kDebug() << "Failed to parse date range" << regExp.cap( 0 );
}
pos += regExp.matchedLength();
}
}
void Task::processTemplate() {
Template* temp = readTemplate(*_templateName);
std::vector<string> subtasks = temp->subTaskList();
int subId = 1;
for (std::vector<string>::iterator iterSub = subtasks.begin(); iterSub != subtasks.end(); iterSub++) {
string subtask = *iterSub;
int posPar = subtask.find('(');
int posFin = subtask.find(')');
string tempSub = subtask.substr(posPar + 1, posFin - posPar - 1);
string subTaskName = subtask.substr(0, posPar);
Task* sub = new Task(_project);
std::stringstream ssId;
ssId << *id() << "." << subId++;
sub->setId(new string(ssId.str()));
sub->setDuration(Duration(1, 0, 0));
sub->setEndDate(endDate());
sub->setShortDescription(new string(subTaskName));
sub->setStartDate(startDate());
sub->setStatus(status());
sub->setTemplateName(new string(tempSub));
_project->addTask(sub);
if (errorOcurred()) {
return;
}
sub->processTemplate();
}
}
WriMoImp* wrimoimp::WriMoImpTest::getNovemberImp()
{
Date startDate(CalendarYear::NOVEMBER, 1, 2015);
Date endDate(CalendarYear::NOVEMBER, 30, 2015);
return new WriMoImp(startDate, endDate);
}
QString CSmfCredMgrClientSymbian::storeRSAKeysL(const QString KeyLabel,
const QString keydata, const QDateTime Validity)
{
RDebug::Printf("Sending store RSA key message to server");
TPtrC labelPtr(qt_QString2TPtrC(KeyLabel));
TPtr dataPtr((qt_QString2HBufC(keydata)->Des()));
QDateTime CurrentTime = QDateTime::currentDateTime();
TTimeIntervalSeconds duration(CurrentTime.secsTo(Validity));
TTime startDate;
startDate.UniversalTime();
TTime endDate(startDate);
endDate += duration;
CSmfRsaKeyParameters* storeRSAKeysparams = CSmfRsaKeyParameters::NewL(
labelPtr, startDate, endDate, (dataPtr.Collapse()));
CleanupStack::PushL(storeRSAKeysparams);
CBufFlat* buf = CBufFlat::NewL(KMinBufSize);
CleanupStack::PushL(buf);
RBufWriteStream stream(*buf);
CleanupClosePushL(stream);
storeRSAKeysparams->ExternalizeL(stream);
stream.CommitL();
TPtr8 bufPtr = buf->Ptr(0);
TIpcArgs args;
args.Set(0, &bufPtr);
CleanupStack::PopAndDestroy(&stream);
HBufC8* retBuf = HBufC8::NewLC(KSHA1HashLengthBytes);
TPtr8 retBufPtr(retBuf->Des());
args.Set(1, &retBufPtr);
iSession.RequestService(ESmfStoreRSAKey, args);
RDebug::Printf("SMF: Message completed");
TBuf<KSHA1HashLengthBytes> key;
key.Copy(retBufPtr);
QString RetString(qt_TDesC2QString(key));
CleanupStack::Pop(retBuf);
CleanupStack::PopAndDestroy(buf);
CleanupStack::PopAndDestroy(storeRSAKeysparams);
RDebug::Printf("-In storeAuthDataL()");
return (RetString);
}
// -----------------------------------------------------------------------------
// CPIMEventPropertyConverter::ConvertRepeatRulePropertyL
// Inserts RRULE proprety from a vEvent to a PIM Event Item as a repeat rule
// -----------------------------------------------------------------------------
//
void CPIMEventPropertyConverter::ConvertRepeatRulePropertyL(
const CPIMParserProperty& aProperty, // property to convert
CPIMEventItem& aItem) // item to insert the field to
{
JELOG2(EPim);
if (aProperty.Name().CompareF(KVersitTokenRRULE) != 0)
{
// Some unsupported recurrence data (i.e. EXRULE)
return;
}
MPIMRepeatRuleData* repeatRule = aItem.GetRepeat();
CParserPropertyValueRecurrence* propertyValue =
static_cast<CParserPropertyValueRecurrence*>(aProperty.Value());
CVersitRecurrence* value = propertyValue->Value();
switch (value->iRepeatType)
{
case CVersitRecurrence::EDaily:
{
repeatRule->SetIntL(EPIMRepeatRuleFrequency, EPIMRepeatRuleDaily);
break;
}
case CVersitRecurrence::EWeekly:
{
repeatRule->SetIntL(EPIMRepeatRuleFrequency, EPIMRepeatRuleWeekly);
repeatRule->SetIntL(EPIMRepeatRuleInterval, value->iInterval);
break;
}
case CVersitRecurrence::EMonthlyByPos:
case CVersitRecurrence::EMonthlyByDay:
{
repeatRule->SetIntL(EPIMRepeatRuleFrequency, EPIMRepeatRuleMonthly);
break;
}
case CVersitRecurrence::EYearlyByMonth:
case CVersitRecurrence::EYearlyByDay:
{
repeatRule->SetIntL(EPIMRepeatRuleFrequency, EPIMRepeatRuleYearly);
break;
}
default:
{
// unknown frequency
return;
}
}
TVersitDateTime* versitEndDate = value->iEndDate;
if (versitEndDate)
{
TPIMDate endDate(versitEndDate->iDateTime);
repeatRule->SetDateL(EPIMRepeatRuleEnd, endDate);
}
aItem.SetRepeating(ETrue);
}
QDate DailyRecurrence::nextOccurrence(const QDate &date, bool include_equals) const {
const KCalendarSystem *calSys = KGlobal::locale()->calendar();
if(include_equals) {
if(date == startDate()) return date;
}
QDate nextdate = date;
if(!include_equals) nextdate = calSys->addDays(nextdate, 1);
if(!endDate().isNull() && nextdate > endDate()) return QDate();
if(nextdate <= startDate()) return firstOccurrence();
if(i_frequency != 1) {
int days = startDate().daysTo(nextdate);
if(days % i_frequency != 0) {
nextdate = calSys->addDays(nextdate, i_frequency - (days % i_frequency));
}
}
if(!endDate().isNull() && nextdate > endDate()) return QDate();
if(hasException(nextdate)) return nextOccurrence(nextdate);
return nextdate;
}
QDate YearlyRecurrence::prevOccurrence(const QDate &date, bool include_equals) const {
const KCalendarSystem *calSys = KGlobal::locale()->calendar();
if(!include_equals) {
if(date > endDate()) return lastOccurrence();
}
QDate prevdate = date;
if(!include_equals) prevdate = calSys->addDays(prevdate, -1);
if(prevdate < startDate()) return QDate();
if(prevdate == startDate()) return startDate();
if(i_frequency != 1) {
int i = (calSys->year(prevdate) - calSys->year(startDate())) % i_frequency;
if(i != 0) {
prevdate = calSys->addYears(prevdate, - i);
}
}
if(calSys->year(prevdate) == calSys->year(startDate())) return startDate();
if(i_dayofyear > 0) {
if(calSys->dayOfYear(prevdate) < i_dayofyear) {
prevdate = calSys->addYears(prevdate, -i_frequency);
if(calSys->year(prevdate) == calSys->year(startDate())) return startDate();
}
if(i_dayofyear > calSys->daysInYear(prevdate)) {
do {
prevdate = calSys->addYears(prevdate, -i_frequency);
if(calSys->year(prevdate) <= calSys->year(startDate())) return startDate();
} while(i_dayofyear > calSys->daysInYear(prevdate));
}
prevdate = calSys->addDays(prevdate, i_dayofyear - calSys->dayOfYear(prevdate));
} else {
int day = i_dayofmonth;
if(i_dayofweek > 0) day = get_day_in_month(calSys->year(prevdate), i_month, i_week, i_dayofweek);
if(day <= 0 || calSys->month(prevdate) < i_month || (calSys->month(prevdate) == i_month && calSys->day(prevdate) < day)) {
do {
prevdate = calSys->addYears(prevdate, -i_frequency);
if(i_dayofweek > 0) day = get_day_in_month(calSys->year(prevdate), i_month, i_week, i_dayofweek);
if(calSys->year(prevdate) == calSys->year(startDate())) return startDate();
} while(day <= 0);
}
if(i_dayofweek <= 0) {
calSys->setYMD(prevdate, calSys->year(prevdate), i_month, 1);
if(day > calSys->daysInMonth(prevdate)) {
do {
prevdate = calSys->addYears(prevdate, -i_frequency);
calSys->setYMD(prevdate, calSys->year(prevdate), i_month, 1);
if(calSys->year(prevdate) <= calSys->year(startDate())) return startDate();
} while(day > calSys->daysInMonth(prevdate));
}
}
calSys->setYMD(prevdate, calSys->year(prevdate), i_month, day);
}
if(prevdate < startDate()) return QDate();
if(hasException(prevdate)) return prevOccurrence(prevdate);
return prevdate;
}
QDate WeeklyRecurrence::nextOccurrence(const QDate &date, bool include_equals) const {
const KCalendarSystem *calSys = KGlobal::locale()->calendar();
if(!include_equals) {
if(date < startDate()) return firstOccurrence();
} else {
if(date <= startDate()) return firstOccurrence();
}
QDate nextdate = date;
if(!include_equals) nextdate = calSys->addDays(nextdate, 1);
if(!endDate().isNull() && nextdate > endDate()) return QDate();
if(i_frequency != 1 && calSys->weekNumber(nextdate) != calSys->weekNumber(startDate())) {
int i = weeks_between_dates(startDate(), nextdate) % i_frequency;
if(i != 0) {
nextdate = calSys->addDays(nextdate, (i_frequency - i) * 7 - (calSys->dayOfWeek(nextdate) - 1));
}
}
int dow = calSys->dayOfWeek(nextdate);
int i = dow;
for(; i <= 7; i++) {
if(b_daysofweek[i - 1]) {
break;
}
}
if(i > 7) {
for(i = 1; i <= 7; i++) {
if(b_daysofweek[i - 1]) {
break;
}
}
if(i > 7) return QDate();
}
if(i < dow) {
nextdate = calSys->addDays(nextdate, (i_frequency * 7) + i - dow);
} else if(i > dow) {
nextdate = calSys->addDays(nextdate, i - dow);
}
if(!endDate().isNull() && nextdate > endDate()) return QDate();
if(hasException(nextdate)) return nextOccurrence(nextdate);
return nextdate;
}
//=============================================================================
// Compare two DateTimes and calculate the elapsed time
//==============================================================================
PeriodData TimeComparer::Compare(const DateTime& start, const DateTime& end)
{
PeriodData pd;
//Convert both DateTime to ISO for comparison
PartialDateTime endDate(end);
PartialDateTime startDate(start);
if (calmath::ExtractTime(endDate.GetFixed()) < calmath::ExtractTime(startDate.GetFixed()))
{
endDate = PartialDateTime(start);
startDate = PartialDateTime(end);
}
pd.elapsedHours = endDate.GetHour() - startDate.GetHour();
pd.elapsedMinutes = endDate.GetMinute() - startDate.GetMinute();
pd.elapsedSeconds = endDate.GetSecond() - startDate.GetSecond();
pd.elapsedMilliseconds = endDate.GetMilliSecond() - startDate.GetMilliSecond();
//borrow to avoid negatives
if (pd.elapsedMilliseconds < 0)
{
pd.elapsedSeconds -= 1;
pd.elapsedMilliseconds += 1000;
}
if (pd.elapsedSeconds < 0)
{
pd.elapsedMinutes -= 1;
pd.elapsedSeconds += 60;
}
if (pd.elapsedMinutes < 0)
{
pd.elapsedHours -= 1;
pd.elapsedMinutes += 60;
}
// set unused date fields
pd.elapsedYears = 0;
pd.elapsedMonths = 0;
pd.elapsedWeeks = 0;
pd.elapsedDays = 0;
return pd;
}
//=============================================================================
// Compare two DateTimes and calculate the elapsed time
//==============================================================================
PeriodData YearWeekDayComparer::Compare(const DateTime& start, const DateTime& end)
{
PeriodData pd;
//Convert both DateTime to ISO for comparison
PartialDateTime endDate(end);
PartialDateTime startDate(start);
SwapPositiveElapsed(startDate, endDate);
CalcBaseDateDiff(pd, startDate, endDate);
if (pd.elapsedMonths< 0 || (pd.elapsedMonths == 0 && pd.elapsedDays < 0))
{
//Need to move years back 1
pd.elapsedYears -= 1;
}
//We create a PartialDateTime for the last full year then count remaining days and weeks
PartialDateTime pDt(startDate.GetYear() + pd.elapsedYears, startDate.GetMonth(), 1, CalType::CalType_ISO);
//we set to first of month in case the start date is on a leap year
FixedDateTime intermediateDT = calmath::ExtractDate(pDt.GetFixed());
if (startDate.GetMonth() == 2 && startDate.GetDay() == 29)
{
if (pDt.IsLeapYear())
intermediateDT += (29 - 1);
else
intermediateDT += (28 - 1);
}
else
intermediateDT += (startDate.GetDay() - 1);
//Find diffrence in days
pd.elapsedDays = static_cast<int>(calmath::ExtractDate(endDate.GetFixed()) - intermediateDT);
pd.elapsedWeeks = pd.elapsedDays / 7;
pd.elapsedDays = pd.elapsedDays % 7;
// set elapsed months to unused
SetUnusedDateFields(pd, false, true, false, false);
// set time to unused
SetUnusedTimeFields(pd, true, true, true, true);
return pd;
}
float student::calcAmountOwed(){
boost::gregorian::date currentDate(student::firstEntryDate());
boost::gregorian::date endDate(studentBill[student::numberEntries()-1].getDate());
float monthTotal=0.0;
float overallTotal=0.0;
for(int index=0; index<student::numberEntries();){
bool currentEntryInMonth = entryInMonth(studentBill[index],currentDate);
if(currentEntryInMonth == true){
monthTotal += studentBill[index].getAmount();
index++;
}
else {
currentDate = startOfNextMonth(currentDate);
overallTotal = monthTotal+overallTotal+(overallTotal*.01);
monthTotal=0.0;
}
}
return (overallTotal=monthTotal+overallTotal+(overallTotal*.01));
}
QDate DailyRecurrence::prevOccurrence(const QDate &date, bool include_equals) const {
const KCalendarSystem *calSys = KGlobal::locale()->calendar();
if(!include_equals) {
if(date > endDate()) return lastOccurrence();
}
QDate prevdate = date;
if(!include_equals) prevdate = calSys->addDays(prevdate, -1);
if(prevdate < startDate()) return QDate();
if(prevdate == startDate()) return startDate();
if(i_frequency != 1) {
int days = startDate().daysTo(prevdate);
if(days % i_frequency != 0) {
prevdate = calSys->addDays(prevdate, -(days % i_frequency));
}
}
if(prevdate < startDate()) return QDate();
if(hasException(prevdate)) return prevOccurrence(prevdate);
return prevdate;
}
QDate WeeklyRecurrence::prevOccurrence(const QDate &date, bool include_equals) const {
const KCalendarSystem *calSys = KGlobal::locale()->calendar();
if(!include_equals) {
if(date > endDate()) return lastOccurrence();
}
QDate prevdate = date;
if(!include_equals) prevdate = calSys->addDays(prevdate, -1);
if(prevdate < startDate()) return QDate();
if(prevdate == startDate()) return startDate();
if(i_frequency != 1 && calSys->weekNumber(prevdate) != calSys->weekNumber(startDate())) {
int i = weeks_between_dates(startDate(), prevdate) % i_frequency;
if(i != 0) {
prevdate = calSys->addDays(prevdate, -(i * 7) + 7 - calSys->dayOfWeek(prevdate));
}
}
int dow_s = calSys->dayOfWeek(startDate());
bool s_week = calSys->weekNumber(prevdate) == calSys->weekNumber(startDate());
int dow = calSys->dayOfWeek(prevdate);
int i = dow;
for(; i <= 7; i++) {
if(b_daysofweek[i - 1] || (s_week && dow_s == i)) {
break;
}
}
if(i > 7) {
for(i = 1; i <= 7; i++) {
if(b_daysofweek[i - 1] || (s_week && dow_s == i)) {
break;
}
}
if(i > 7) return QDate();
}
if(i > dow) {
prevdate = calSys->addDays(prevdate, -(i_frequency * 7) + dow - i);
} else if(i < dow) {
prevdate = calSys->addDays(prevdate, dow - i);
}
if(prevdate < startDate()) return QDate();
if(hasException(prevdate)) return prevOccurrence(prevdate);
return prevdate;
}
ReadingPlanWizardDatesPage::ReadingPlanWizardDatesPage(wxWizard *parent) : wxWizardPageSimple(parent)
{
wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL );
wxBoxSizer *topDatesizer = new wxBoxSizer( wxHORIZONTAL );
wxBoxSizer *startDatesizer = new wxBoxSizer( wxVERTICAL );
wxBoxSizer *endDatesizer = new wxBoxSizer( wxVERTICAL );
wxGridSizer *weekdaysSizer = new wxGridSizer(2,4,2,10);
m_calStart = new wxCalendarCtrl(this, ID_CalendarCtrlStart ,
wxDateTime(wxDefaultDateTime).SetToCurrent(),
wxDefaultPosition,
wxDefaultSize,
wxCAL_SUNDAY_FIRST |
wxCAL_SHOW_HOLIDAYS |
wxRAISED_BORDER );
wxDateTime endDate(wxDefaultDateTime);
endDate.SetToCurrent();
endDate.Add(wxDateSpan(1,0,0,-1));
m_calEnd = new wxCalendarCtrl(this, ID_CalendarCtrlEnd,
endDate,
wxDefaultPosition,
wxDefaultSize,
wxCAL_SUNDAY_FIRST |
wxCAL_SHOW_HOLIDAYS |
wxRAISED_BORDER );
// m_calStart->Hide();
// m_calEnd->Hide();
m_strStart = new wxStaticText(this, -1, _("Start Date:"), wxDefaultPosition, wxDefaultSize, wxST_NO_AUTORESIZE);
m_strEnd = new wxStaticText(this, -1, _("End Date:"), wxDefaultPosition, wxDefaultSize, wxST_NO_AUTORESIZE);
m_strEnd->SetMinSize(wxSize(m_calEnd->GetSize().GetWidth(), m_strEnd->GetSize().GetHeight()));
m_strStart->SetMinSize(wxSize(m_calStart->GetSize().GetWidth(), m_strStart->GetSize().GetHeight()));
startDatesizer->Add(m_strStart, 0);
startDatesizer->Add(m_calStart, 1, wxEXPAND);
// startDatesizer->SetSizeHints(this);
//
endDatesizer->Add(m_strEnd, 0);
endDatesizer->Add(m_calEnd, 1, wxEXPAND);
topDatesizer->Add(startDatesizer, 1, wxEXPAND, 10);
topDatesizer->Add(15,5);
topDatesizer->Add(endDatesizer, 1, wxEXPAND, 10);
// SetSizer( topDatesizer );
// topDatesizer->SetSizeHints(this);
m_statBox = new wxStaticBox(this, -1, _("Days of Week"));
wxStaticBoxSizer* statsizer = new wxStaticBoxSizer(m_statBox, wxHORIZONTAL);
m_ckSunday = new wxCheckBox(this, ID_CheckCtrlSun, _("Sunday"), wxDefaultPosition, wxSize(-1,-1));
m_ckSunday->SetValue(true);
m_ckMonday = new wxCheckBox(this, ID_CheckCtrlMon, _("Monday"), wxDefaultPosition, wxSize(-1,-1));
m_ckMonday->SetValue(true);
m_ckTuesday = new wxCheckBox(this, ID_CheckCtrlTue, _("Tuesday"), wxDefaultPosition, wxSize(-1,-1));
m_ckTuesday->SetValue(true);
m_ckWednesday = new wxCheckBox(this, ID_CheckCtrlWed, _("Wednesday"), wxDefaultPosition, wxSize(-1,-1));
m_ckWednesday->SetValue(true);
m_ckThursday = new wxCheckBox(this, ID_CheckCtrlThu, _("Thursday"), wxDefaultPosition, wxSize(-1,-1));
m_ckThursday->SetValue(true);
m_ckFriday = new wxCheckBox(this, ID_CheckCtrlFri, _("Friday"), wxDefaultPosition, wxSize(-1,-1));
m_ckFriday->SetValue(true);
m_ckSaturday = new wxCheckBox(this, ID_CheckCtrlSat, _("Saturday"), wxDefaultPosition, wxSize(-1,-1));
m_ckSaturday->SetValue(true);
weekdaysSizer->Add(m_ckSunday);
weekdaysSizer->Add(m_ckMonday);
weekdaysSizer->Add(m_ckTuesday);
weekdaysSizer->Add(m_ckWednesday);
weekdaysSizer->Add(m_ckThursday);
weekdaysSizer->Add(m_ckFriday);
weekdaysSizer->Add(m_ckSaturday);
statsizer->Add(weekdaysSizer);
m_lblDayTotal = new wxStaticText(this, ID_TextCtrlTotal, _("Total Days:") + wxString(wxT(" 0")),wxDefaultPosition, wxSize(-1,-1));
m_dateBegin = (RPDate)(&m_calStart->GetDate());
m_dateEnd = (RPDate)(&m_calEnd->GetDate());
m_dayFlags = SUNDAY | MONDAY | TUESDAY | WEDNESDAY | THURSDAY | FRIDAY | SATURDAY;
UpdateDays();
topsizer->Add(topDatesizer,1);
topsizer->Add(5,15);
topsizer->Add(statsizer,0);
topsizer->Add(5,5);
topsizer->Add(m_lblDayTotal,0);
SetSizer( topsizer );
topsizer->SetSizeHints(this);
}
RcppExport SEXP xbrlProcessContexts(SEXP epaDoc) {
xmlDocPtr doc = (xmlDocPtr) R_ExternalPtrAddr(epaDoc);
xmlXPathContextPtr context = xmlXPathNewContext(doc);
xmlXPathObjectPtr context_res = xmlXPathEvalExpression((xmlChar*) "//*[local-name()='context']", context);
xmlNodeSetPtr context_nodeset = context_res->nodesetval;
int context_nodeset_ln = context_nodeset->nodeNr;
xmlXPathFreeContext(context);
CharacterVector contextId(context_nodeset_ln);
CharacterVector scheme(context_nodeset_ln);
CharacterVector identifier(context_nodeset_ln);
CharacterVector startDate(context_nodeset_ln);
CharacterVector endDate(context_nodeset_ln);
CharacterVector dimension1(context_nodeset_ln);
CharacterVector value1(context_nodeset_ln);
CharacterVector dimension2(context_nodeset_ln);
CharacterVector value2(context_nodeset_ln);
CharacterVector dimension3(context_nodeset_ln);
CharacterVector value3(context_nodeset_ln);
CharacterVector dimension4(context_nodeset_ln);
CharacterVector value4(context_nodeset_ln);
for (int i=0; i < context_nodeset_ln; i++) {
xmlNodePtr context_node = context_nodeset->nodeTab[i];
xmlChar *tmp_str;
if ((tmp_str = xmlGetProp(context_node, (xmlChar*) "id"))) {
contextId[i] = (char *) tmp_str;
xmlFree(tmp_str);
} else {
contextId[i] = NA_STRING;
}
scheme[i] = identifier[i] = startDate[i] = endDate[i] =
dimension1[i] = value1[i] = dimension2[i] = value2[i] =
dimension3[i] = value3[i] = dimension4[i] = value4[i] = NA_STRING;
xmlNodePtr child_node = context_node->xmlChildrenNode;
while (child_node) {
if (!xmlStrcmp(child_node->name, (xmlChar*) "entity")) {
xmlNodePtr gchild_node = child_node->xmlChildrenNode;
while (gchild_node) {
if (!xmlStrcmp(gchild_node->name, (xmlChar*) "identifier")) {
if ((tmp_str = xmlGetProp(gchild_node, (xmlChar*) "scheme"))) {
scheme[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
if ((tmp_str = xmlNodeListGetString(doc, gchild_node->xmlChildrenNode, 1))) {
identifier[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
} else if (!xmlStrcmp(gchild_node->name, (xmlChar*) "segment")) {
xmlNodePtr ggchild_node = gchild_node->xmlChildrenNode;
int dimn = 1;
while (ggchild_node) {
if (!xmlStrcmp(ggchild_node->name, (xmlChar*) "explicitMember")) {
if ((tmp_str = xmlGetProp(ggchild_node, (xmlChar*) "dimension"))) {
if (dimn == 1)
dimension1[i] = (char *) tmp_str;
else if (dimn == 2)
dimension2[i] = (char *) tmp_str;
else if (dimn == 3)
dimension3[i] = (char *) tmp_str;
else if (dimn == 4)
dimension4[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
if ((tmp_str = xmlNodeListGetString(doc, ggchild_node->xmlChildrenNode, 1))) {
if (dimn == 1)
value1[i] = (char *) tmp_str;
else if (dimn == 2)
value2[i] = (char *) tmp_str;
else if (dimn == 3)
value3[i] = (char *) tmp_str;
else if (dimn == 4)
value4[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
dimn++;
}
ggchild_node = ggchild_node->next;
}
}
gchild_node = gchild_node->next;
}
} else if (!xmlStrcmp(child_node->name, (xmlChar*) "period")) {
xmlNodePtr gchild_node = child_node->xmlChildrenNode;
while (gchild_node) {
if (!xmlStrcmp(gchild_node->name, (xmlChar*) "startDate")) {
if ((tmp_str = xmlNodeListGetString(doc, gchild_node->xmlChildrenNode, 1))) {
startDate[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
} else if (!xmlStrcmp(gchild_node->name, (xmlChar*) "endDate")) {
if ((tmp_str = xmlNodeListGetString(doc, gchild_node->xmlChildrenNode, 1))) {
endDate[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
} else if (!xmlStrcmp(gchild_node->name, (xmlChar*) "instant")) {
if ((tmp_str = xmlNodeListGetString(doc, gchild_node->xmlChildrenNode, 1))) {
endDate[i] = (char *) tmp_str;
xmlFree(tmp_str);
}
}
gchild_node = gchild_node->next;
}
}
child_node = child_node->next;
}
}
xmlXPathFreeObject(context_res);
return DataFrame::create(Named("contextId")=contextId,
Named("scheme")=scheme,
Named("identifier")=identifier,
Named("startDate")=startDate,
Named("endDate")=endDate,
Named("dimension1")=dimension1,
Named("value1")=value1,
Named("dimension2")=dimension2,
Named("value2")=value2,
Named("dimension3")=dimension3,
Named("value3")=value3,
Named("dimension4")=dimension4,
Named("value4")=value4);
}
int ChartItemModel::rowCount( const QModelIndex &/*parent */) const
{
return startDate().daysTo( endDate() ) + 1;
}
QDate YearlyRecurrence::nextOccurrence(const QDate &date, bool include_equals) const {
const KCalendarSystem *calSys = KGlobal::locale()->calendar();
if(!include_equals) {
if(date < startDate()) return firstOccurrence();
} else {
if(date <= startDate()) return firstOccurrence();
}
QDate nextdate = date;
if(!include_equals) nextdate = calSys->addDays(nextdate, 1);
if(!endDate().isNull() && nextdate > endDate()) return QDate();
if(calSys->year(nextdate) == calSys->year(startDate())) {
nextdate = calSys->addYears(nextdate, i_frequency);
calSys->setYMD(nextdate, calSys->year(nextdate), 1, 1);
} else if(i_frequency != 1) {
int i = (calSys->year(nextdate) - calSys->year(startDate())) % i_frequency;
if(i != 0) {
nextdate = calSys->addYears(nextdate, i_frequency - i);
calSys->setYMD(nextdate, calSys->year(nextdate), 1, 1);
}
}
if(i_dayofyear > 0) {
if(calSys->dayOfYear(nextdate) > i_dayofyear) {
nextdate = calSys->addYears(nextdate, i_frequency);
}
if(i_dayofyear > calSys->daysInYear(nextdate)) {
int i = 10;
do {
if(i == 0) return QDate();
nextdate = calSys->addYears(nextdate, i_frequency);
i--;
} while(i_dayofyear > calSys->daysInYear(nextdate));
}
nextdate = calSys->addDays(nextdate, i_dayofyear - calSys->dayOfYear(nextdate));
} else {
int day = i_dayofmonth;
if(i_dayofweek > 0) day = get_day_in_month(calSys->year(nextdate), i_month, i_week, i_dayofweek);
if(day == 0 || calSys->month(nextdate) > i_month || (calSys->month(nextdate) == i_month && calSys->day(nextdate) > day)) {
do {
nextdate = calSys->addYears(nextdate, i_frequency);
day = get_day_in_month(calSys->year(nextdate), i_month, i_week, i_dayofweek);
if(!endDate().isNull() && calSys->year(nextdate) > calSys->year(endDate())) return QDate();
} while(day == 0);
}
if(i_dayofweek <= 0) {
calSys->setYMD(nextdate, calSys->year(nextdate), i_month, 1);
if(day > calSys->daysInMonth(nextdate)) {
int i = 10;
do {
if(i == 0) return QDate();
nextdate = calSys->addYears(nextdate, i_frequency);
calSys->setYMD(nextdate, calSys->year(nextdate), i_month, 1);
i--;
} while(day > calSys->daysInMonth(nextdate));
}
}
calSys->setYMD(nextdate, calSys->year(nextdate), i_month, day);
}
if(!endDate().isNull() && nextdate > endDate()) return QDate();
if(hasException(nextdate)) return nextOccurrence(nextdate);
return nextdate;
}
int main(int argc, char *argv[])
{
// make sure that each time you run your application, a valid access token is provided
if (argc < 2 || argc > 3) {
std::cerr << "Usage: ./<executable_name> \"<access_token>\" [\"<Extension_identifier\"]" << std::endl;
std::cerr << " example: ./democallcosts \"1|V_pmPvEm25-HrqAzERx_nvJbBvNs~q3F|1|D~nbBUf87k~7I12F79T-nJnHU12Y.4Aq\"" << std::endl;
exit(EXIT_FAILURE);
}
// We will make a Call report, so we need a Report object
ReportProxy *report = new ReportProxy;
if (NULL == report) {
std::cerr << "Failed creating a Report object" << std::endl;
exit(EXIT_FAILURE);
}
// Authentication Data - passed from command line
std::string accessToken(argv[1]);
// filling in the header with the user credentials
report->soap->header = new SOAP_ENV__Header;
if (NULL == report->soap->header) {
std::cerr << "Failed creating a SOAP_ENV__Header object" << std::endl;
exit(EXIT_FAILURE);
}
report->soap->header->ns3__serverInfo = NULL;
report->soap->header->ns3__userCredentials = new _ns3__userCredentials;
if (NULL == report->soap->header->ns3__userCredentials) {
std::cerr << "Failed creating an _ns3__userCredentials object" << std::endl;
exit(EXIT_FAILURE);
}
report->soap->header->ns3__userCredentials->accessToken = accessToken;
// creating 2 objects for the request and for the response
_ns20__CallCosts *request = new _ns20__CallCosts;
if (NULL == request) {
std::cerr << "Failed creating a CallReport object" << std::endl;
exit(EXIT_FAILURE);
}
_ns20__CallCostsResponse response;
// User ID - passed from the command line or randomly generated
std::string parentID;
if (3 == argc) {
// User ID was passed from command line
std::string temp(argv[2]);
parentID = temp;
} else {
// random extension ID
std::cout << "No extension ID was provided, will randomly generate one" << std::endl;
// getting all extensions
// we need an Extension object
ExtensionProxy *extension = new ExtensionProxy;
if (NULL == extension) {
std::cerr << "Failed creating an Extension object" << std::endl;
exit(EXIT_FAILURE);
}
// filling in the header with the user credentials
extension->soap->header = new SOAP_ENV__Header;
if (NULL == extension->soap->header) {
std::cerr << "Failed creating a SOAP_ENV__Header object" << std::endl;
exit(EXIT_FAILURE);
}
extension->soap->header->ns3__serverInfo = NULL;
extension->soap->header->ns3__userCredentials = new _ns3__userCredentials;
if (NULL == extension->soap->header->ns3__userCredentials) {
std::cerr << "Failed creating a _ns3__userCredentials object" << std::endl;
exit(EXIT_FAILURE);
}
extension->soap->header->ns3__userCredentials->accessToken = accessToken;
// creating 2 objects for the request and for the response
_ns13__GetExtensions *extRequest = new _ns13__GetExtensions;
if (NULL == extRequest) {
std::cerr << "Failed creating a _ns13__GetExtensions object" << std::endl;
exit(EXIT_FAILURE);
}
_ns13__GetExtensionsResponse extResponse;
// making the request for getting extensions and getting the response
int errCodeExt = extension->GetExtensions(extRequest, extResponse);
if (SOAP_OK == errCodeExt) {
// no error
std::cout << "OK retrieving extensions" << std::endl;
if (0 == extResponse.extension.size()) {
// no extensions exist
std::cerr << "No extensions are defined" << std::endl;
exit(EXIT_FAILURE);
}
// found extensions
// randomly choosing an extension
srand(time(NULL));
int randomIndex = rand() % extResponse.extension.size();
// getting the id of the user
std::string randomID = *extResponse.extension.at(randomIndex)->identifier;
std::cout << "Using random extension identifier " << randomID << std::endl;
parentID = randomID;
} else {
// error found
soap *s = new soap;
if (NULL == s) {
std::cerr << "Failed creating a soap object" << std::endl;
exit(EXIT_FAILURE);
}
s->error = errCodeExt;
soap_print_fault(s, stderr);
delete s;
}
}
request->__CallCosts_sequence = new __ns20__CallCosts_sequence;
if (NULL == request->__CallCosts_sequence) {
std::cerr << "Failed creating a __ns20__CallCosts_sequence" << std::endl;
exit(EXIT_FAILURE);
}
request->__CallCosts_sequence->ns21__userIdentifier = &parentID;
//get current date for the endDate parameter of the interval for the report
time_t the_time = time(NULL);
struct tm *a_time = localtime(&the_time);
char *end_date = (char*)malloc(12 * sizeof(char));
if (NULL == end_date) {
std::cerr << "Failed creating string for end_date" << std::endl;
exit(EXIT_FAILURE);
}
sprintf(end_date, "%d-%02d-%d", a_time->tm_year + 1900, a_time->tm_mon + 1, a_time->tm_mday);
// information about the call report(interval)
std::string startDate(START_DATE);
std::string endDate(end_date);
free(end_date);
request->__CallCosts_sequence->ns21__interval = new _ns21__interval;
if (NULL == request->__CallCosts_sequence->ns21__interval) {
std::cerr << "Failed creating a _ns21__interval object" << std::endl;
exit(EXIT_FAILURE);
}
// filling in the information about the call report (interval)
request->__CallCosts_sequence->ns21__interval->startDate = &startDate;
request->__CallCosts_sequence->ns21__interval->endDate = &endDate;
// making the request and getting the response
int errCode = report->CallCosts(request, response);
if (SOAP_OK == errCode) {
// no error
std::cout << "OK retrieving call costs" << std::endl;
std::cout << *response.ns21__totalCalls << " calls have been made between " << startDate << " and " << endDate;
std::cout << " with a total cost of " << *response.ns21__cost << " " << *response.ns21__currency << std::endl;
} else {
// error found
soap *s = new soap;
if (NULL == s) {
std::cerr << "Failed creating a soap object" << std::endl;
exit(EXIT_FAILURE);
}
s->error = errCode;
soap_print_fault(s, stderr);
std::cerr << "Please check the log files for more information" << std::endl;
delete s;
}
delete request->__CallCosts_sequence->ns21__interval;
delete request->__CallCosts_sequence;
request->~_ns20__CallCosts();
delete request;
return 0;
}
bool DateRange::operator==(DateRange const& other) const
{
return m_startDate == other.m_startDate && endDate() == other.endDate();
}
bool RecurrenceWidget::save(bool externaltxn, RecurrenceChangePolicy cp, QString *message)
{
if (! message)
message = new QString();
if (DEBUG)
qDebug("%s::save(%d, %d, %p) entered with id %d type %s",
qPrintable(objectName()), externaltxn, cp, message, _parentId,
qPrintable(_parentType));
if (! modified())
return true;
if (_parentId < 0 || _parentType.isEmpty())
{
*message = tr("Could not save Recurrence information. The "
"parent object/event has not been set.");
if (! externaltxn)
QMessageBox::warning(this, tr("Missing Data"), *message);
else
qWarning("%s", qPrintable(*message));
return false;
}
if (! externaltxn && cp == NoPolicy)
{
cp = getChangePolicy();
if (cp == NoPolicy)
return false;
}
else if (externaltxn && cp == NoPolicy)
{
*message = tr("You must choose how open events are to be handled");
qWarning("%s", qPrintable(*message));
return false;
}
XSqlQuery rollbackq;
if (! externaltxn)
{
XSqlQuery beginq("BEGIN;");
rollbackq.prepare("ROLLBACK;");
}
XSqlQuery recurq;
if (isRecurring())
{
if (_id > 0)
{
if (cp == ChangeFuture)
{
XSqlQuery futureq;
futureq.prepare("SELECT splitRecurrence(:parent_id, :parent_type,"
" :splitdate) AS newrecurid;");
futureq.bindValue(":parent_id", _parentId);
futureq.bindValue(":parent_type", _parentType);
futureq.bindValue(":splitdate", startDate());
futureq.exec();
if (futureq.first())
{
int result = futureq.value("newrecurid").toInt();
if (result > 0)
{
_id = result;
futureq.prepare("SELECT recur_parent_id"
" FROM recur"
" WHERE recur_id=:recur_id;");
futureq.bindValue(":recur_id", _id);
futureq.exec();
if (futureq.first())
_parentId = futureq.value("recur_parent_id").toInt();
}
else if (result < 0)
{
*message = storedProcErrorLookup("splitRecurrence", result);
if (! externaltxn)
{
rollbackq.exec();
QMessageBox::warning(this, tr("Processing Error"), *message);
}
else
qWarning("%s", qPrintable(*message));
return false;
}
}
// one check for potentially 2 queries
if (futureq.lastError().type() != QSqlError::NoError)
{
*message = futureq.lastError().text();
if (! externaltxn)
{
rollbackq.exec();
QMessageBox::warning(this, tr("Database Error"), *message);
}
else
qWarning("%s", qPrintable(*message));
return false;
}
}
recurq.prepare("UPDATE recur SET"
" recur_parent_id=:recur_parent_id,"
" recur_parent_type=UPPER(:recur_parent_type),"
" recur_period=:recur_period,"
" recur_freq=:recur_freq,"
" recur_start=:recur_start,"
" recur_end=:recur_end,"
" recur_max=:recur_max"
" WHERE (recur_id=:recurid)"
" RETURNING recur_id;");
recurq.bindValue(":recurid", _id);
}
else
{
recurq.prepare("INSERT INTO recur ("
" recur_parent_id, recur_parent_type,"
" recur_period, recur_freq,"
" recur_start, recur_end,"
" recur_max"
") VALUES ("
" :recur_parent_id, UPPER(:recur_parent_type),"
" :recur_period, :recur_freq,"
" :recur_start, :recur_end,"
" :recur_max"
") RETURNING recur_id;");
}
recurq.bindValue(":recur_parent_id", _parentId);
recurq.bindValue(":recur_parent_type", _parentType);
recurq.bindValue(":recur_period", periodCode());
recurq.bindValue(":recur_freq", frequency());
recurq.bindValue(":recur_start", startDateTime());
if (endDate() < _eot.date())
recurq.bindValue(":recur_end", endDateTime());
recurq.bindValue(":recur_max", max());
recurq.exec();
if (recurq.first())
{
_id = recurq.value("recur_id").toInt();
_prevParentId = _parentId;
_prevParentType = _parentType;
_prevEndDateTime = endDateTime();
_prevFrequency = frequency();
_prevMax = max();
_prevPeriod = period();
_prevRecurring = isRecurring();
_prevStartDateTime = startDateTime();
}
}
else // ! isRecurring()
{
recurq.prepare("DELETE FROM recur"
" WHERE ((recur_parent_id=:recur_parent_id)"
" AND (UPPER(recur_parent_type)=UPPER(:recur_parent_type)));");
recurq.bindValue(":recur_parent_id", _parentId);
recurq.bindValue(":recur_parent_type", _parentType);
recurq.exec();
}
if (recurq.lastError().type() != QSqlError::NoError)
{
*message = recurq.lastError().text();
if (! externaltxn)
{
rollbackq.exec();
QMessageBox::warning(this, tr("Database Error"), *message);
}
else
qWarning("%s", qPrintable(*message));
return false;
}
if (cp == ChangeFuture)
{
int procresult = -1;
QString procname = "deleteOpenRecurringItems";
XSqlQuery cfq;
cfq.prepare("SELECT deleteOpenRecurringItems(:parentId, :parentType,"
" :splitdate, false) AS result;");
cfq.bindValue(":parentId", _parentId);
cfq.bindValue(":parentType", _parentType);
cfq.bindValue(":splitdate", startDate());
cfq.exec();
if (cfq.first())
{
procresult = cfq.value("result").toInt();
if (procresult >= 0)
{
QString procname = "createOpenRecurringItems";
cfq.prepare("SELECT createRecurringItems(:parentId, :parentType)"
" AS result;");
cfq.bindValue(":parentId", _parentId);
cfq.bindValue(":parentType", _parentType);
cfq.exec();
if (cfq.first())
procresult = cfq.value("result").toInt();
}
}
// error handling for either 1 or 2 queries so not elseif
// check cfq.lastError() first to avoid misreporting db errs as -1
if (cfq.lastError().type() != QSqlError::NoError)
{
*message = cfq.lastError().text();
if (! externaltxn)
{
rollbackq.exec();
QMessageBox::critical(this, tr("Database Error"), *message);
}
else
qWarning("%s", qPrintable(*message));
return false;
}
else if (procresult < 0)
{
*message = storedProcErrorLookup(procname, procresult);
if (! externaltxn)
{
rollbackq.exec();
QMessageBox::critical(this, tr("Processing Error"), *message);
}
else
qWarning("%s", qPrintable(*message));
return false;
}
}
if (! externaltxn)
XSqlQuery commitq("COMMIT;");
return true;
}
QDate MonthlyRecurrence::prevOccurrence(const QDate &date, bool include_equals) const {
const KCalendarSystem *calSys = KGlobal::locale()->calendar();
if(!include_equals) {
if(date > endDate()) return lastOccurrence();
}
QDate prevdate = date;
if(!include_equals) prevdate = calSys->addDays(prevdate, -1);
if(prevdate < startDate()) return QDate();
if(prevdate == startDate()) return startDate();
int prevday = -1;
if(i_frequency != 1 && calSys->month(prevdate) != calSys->month(startDate())) {
int i = months_between_dates(startDate(), prevdate) % i_frequency;
if(i != 0) {
if(i > 1) prevday = 1;
else prevday = calSys->day(prevdate);
prevdate = calSys->addMonths(prevdate, -i);
calSys->setYMD(prevdate, calSys->year(prevdate), calSys->month(prevdate), calSys->daysInMonth(prevdate));
}
}
if(calSys->month(prevdate) == calSys->month(startDate())) return startDate();
int day = i_day;
if(i_dayofweek > 0) day = get_day_in_month(prevdate, i_week, i_dayofweek);
else if(i_day < 1) day = calSys->daysInMonth(prevdate) + i_day;
if(wh_weekendhandling == WEEKEND_HANDLING_BEFORE) {
QDate date;
calSys->setYMD(date, calSys->year(prevdate), calSys->month(prevdate), day);
int wday = calSys->dayOfWeek(date);
if(wday == 6) day -= 1;
else if(wday == 7) day -= 2;
if(day <= 0) {
prevdate = calSys->addMonths(prevdate, -1);
day = calSys->daysInMonth(prevdate) + day;
}
} else if(wh_weekendhandling == WEEKEND_HANDLING_AFTER) {
QDate date;
calSys->setYMD(date, calSys->year(prevdate), calSys->month(prevdate), day);
int wday = calSys->dayOfWeek(date);
if(wday == 6) day += 2;
else if(wday == 7) day += 1;
if(day > calSys->daysInMonth(prevdate) && prevday > 0 && prevday >= day - calSys->daysInMonth(prevdate)) {
day -= calSys->daysInMonth(prevdate);
prevdate = calSys->addMonths(prevdate, 1);
calSys->setYMD(prevdate, calSys->year(prevdate), calSys->month(prevdate), day);
}
}
if(day <= 0 || calSys->day(prevdate) < day) {
do {
if(i_frequency > 1) prevday = 1;
else prevday = calSys->day(prevdate);
prevdate = calSys->addMonths(prevdate, -i_frequency);
if(calSys->month(prevdate) == calSys->month(startDate())) return startDate();
if(calSys->month(prevdate) < calSys->month(startDate())) return QDate();
day = i_day;
if(i_dayofweek > 0) day = get_day_in_month(prevdate, i_week, i_dayofweek);
else if(i_day < 1) day = calSys->daysInMonth(prevdate) + i_day;
if(wh_weekendhandling == WEEKEND_HANDLING_BEFORE) {
QDate date;
calSys->setYMD(date, calSys->year(prevdate), calSys->month(prevdate), day);
int wday = calSys->dayOfWeek(date);
if(wday == 6) day -= 1;
else if(wday == 7) day -= 2;
if(day <= 0) {
prevdate = calSys->addMonths(prevdate, -1);
day = calSys->daysInMonth(prevdate) + day;
}
} else if(wh_weekendhandling == WEEKEND_HANDLING_AFTER) {
QDate date;
calSys->setYMD(date, calSys->year(prevdate), calSys->month(prevdate), day);
int wday = calSys->dayOfWeek(date);
if(wday == 6) day += 2;
else if(wday == 7) day += 1;
if(day > calSys->daysInMonth(prevdate) && prevday > 0 && prevday >= day - calSys->daysInMonth(prevdate)) {
day -= calSys->daysInMonth(prevdate);
prevdate = calSys->addMonths(prevdate, 1);
calSys->setYMD(prevdate, calSys->year(prevdate), calSys->month(prevdate), day);
} else {
calSys->setYMD(prevdate, calSys->year(prevdate), calSys->month(prevdate), calSys->daysInMonth(prevdate));
}
}
} while(day <= 0 || day > calSys->daysInMonth(prevdate));
}
calSys->setYMD(prevdate, calSys->year(prevdate), calSys->month(prevdate), day);
if(prevdate < startDate()) return QDate();
if(hasException(prevdate)) return prevOccurrence(prevdate);
return prevdate;
}
