konsolekalendar.cpp

Go to the documentation of this file.

/*******************************************************************************
 * konsolekalendar.cpp                                                         *
 *                                                                             *
 * KonsoleKalendar is a command line interface to KDE calendars                *
 * Copyright (C) 2002-2004  Tuukka Pasanen <illuusio@mailcity.com>             *
 * Copyright (C) 2003-2005  Allen Winter <winter@kde.org>                      *
 * Copyright (C) 2010-2011  Timothy Pearson <kb9vqf@pearsoncomputing.net>      *
 *                                                                             *
 * This program is free software; you can redistribute it and/or modify        *
 * it under the terms of the GNU General Public License as published by        *
 * the Free Software Foundation; either version 2 of the License, or           *
 * (at your option) any later version.                                         *
 *                                                                             *
 * This program is distributed in the hope that it will be useful,             *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of              *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                *
 * GNU General Public License for more details.                                *
 *                                                                             *
 * You should have received a copy of the GNU General Public License           *
 * along with this program; if not, write to the Free Software                 *
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
 *                                                                             *
 * As a special exception, permission is given to link this program            *
 * with any edition of TQt, and distribute the resulting executable,           *
 * without including the source code for TQt in the source distribution.       *
 *                                                                             *
 ******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
 
#include <tqdatetime.h>
#include <tqfile.h>
#include <tqtextstream.h>
 
#include <kdebug.h>
#include <tdelocale.h>
 
#include <libkcal/calendarlocal.h>
#include <libkcal/resourcecalendar.h>
#include <libkcal/calendarresources.h>
#include <libkcal/calendar.h>
#include <libkcal/event.h>
#include <libkcal/htmlexport.h>
#include <libtdepim/kpimprefs.h>
 
#include "konsolekalendar.h"
#include "konsolekalendaradd.h"
#include "konsolekalendarchange.h"
#include "konsolekalendardelete.h"
#include "konsolekalendarexports.h"
 
using namespace KCal;
using namespace std;
 
KonsoleKalendar::KonsoleKalendar( KonsoleKalendarVariables *variables )
{
  m_variables = variables;
}
 
KonsoleKalendar::~KonsoleKalendar()
{
}
 
bool KonsoleKalendar::importCalendar()
{
  KonsoleKalendarAdd add( m_variables );
 
  kdDebug() << "konsolecalendar.cpp::importCalendar() | importing now!"
            << endl;
  return( add.addImportedCalendar() );
}
 
bool KonsoleKalendar::createCalendar()
{
  bool status = false;
  CalendarLocal newCalendar( KPimPrefs::timezone() );
 
  if ( m_variables->isDryRun() ) {
    cout << i18n( "Create Calendar <Dry Run>: %1" ).
      arg( m_variables->getCalendarFile() ).local8Bit().data()
         << endl;
  } else {
    kdDebug() << "konsolekalendar.cpp::createCalendar() | "
              << "Creating calendar file: "
              << m_variables->getCalendarFile().local8Bit().data()
              << endl;
 
    if ( m_variables->isVerbose() ) {
      cout << i18n( "Create Calendar <Verbose>: %1" ).
        arg( m_variables->getCalendarFile() ).local8Bit().data()
           << endl;
    }
 
    if ( newCalendar.save( m_variables->getCalendarFile() ) ) {
      newCalendar.close();
      status = true;
    }
  }
  return status;
}
 
bool KonsoleKalendar::showInstance()
{
  bool status = true;
  TQFile f;
  TQString title;
  Event *event;
 
  if ( m_variables->isDryRun() ) {
    cout << i18n( "View Events <Dry Run>:" ).local8Bit().data()
         << endl;
    printSpecs();
  } else {
 
    kdDebug() << "konsolekalendar.cpp::showInstance() | "
              << "open export file"
              << endl;
 
    if ( m_variables->isExportFile() ) {
      f.setName( m_variables->getExportFile() );
      if ( !f.open( IO_WriteOnly ) ) {
    status = false;
    kdDebug() << "konsolekalendar.cpp::showInstance() | "
                  << "unable to open export file "
                  << m_variables->getExportFile()
                  << endl;
      }
    } else {
      f.open( IO_WriteOnly, stdout );
    }
 
    if ( status ) {
      kdDebug() << "konsolekalendar.cpp::showInstance() | "
                << "opened successful"
                << endl;
 
      if ( m_variables->isVerbose() ) {
    cout << i18n( "View Event <Verbose>:" ).local8Bit().data()
             << endl;
    printSpecs();
      }
 
      TQTextStream ts( &f );
 
      if ( m_variables->getExportType() != ExportTypeHTML &&
           m_variables->getExportType() != ExportTypeMonthHTML ) {
 
    if ( m_variables->getAll() ) {
      kdDebug() << "konsolekalendar.cpp::showInstance() | "
                    << "view all events sorted list"
                    << endl;
 
      Event::List sortedList =
            m_variables->getCalendar()->events( EventSortStartDate );
          if( sortedList.count() > 0 )
          {
            TQDate dt, firstdate, lastdate;
            firstdate = sortedList.first()->dtStart().date();
            lastdate = sortedList.last()->dtStart().date();
            for ( dt = firstdate;
                  dt <= lastdate && status != false;
                  dt = dt.addDays(1) ) {
              Event::List events =
                m_variables->getCalendar()->events( dt,
                                                    EventSortStartDate,
                                                    SortDirectionAscending );
              status = printEventList( &ts, &events, dt );
            }
          }
 
    } else if ( m_variables->isUID() ) {
      kdDebug() << "konsolekalendar.cpp::showInstance() | "
                    << "view events by uid list"
                    << endl;
      //TODO: support a list of UIDs
      event = m_variables->getCalendar()->event( m_variables->getUID() );
      //If this UID represents a recurring Event,
          //only the first day of the Event will be printed
      status = printEvent ( &ts, event, event->dtStart().date() );
 
        } else if ( m_variables->isNext() ) {
          kdDebug() << "konsolekalendar.cpp::showInstance() | "
                    << "Show next activity in calendar"
                    << endl;
 
          TQDateTime datetime = m_variables->getStartDateTime();
          datetime = datetime.addDays( 720 );
 
      TQDate dt;
      for ( dt = m_variables->getStartDateTime().date();
                dt <= datetime.date();
                dt = dt.addDays(1) ) {
        Event::List events =
              m_variables->getCalendar()->events( dt,
                                                  EventSortStartDate,
                                                  SortDirectionAscending );
            // finished here when we get the next event
            if ( events.count() > 0 ) {
          kdDebug() << "konsolekalendar.cpp::showInstance() | "
                        << "Got the next event"
                        << endl;
              printEvent( &ts, events.first(), dt );
              return true;
        }
          }
    } else {
      kdDebug() << "konsolekalendar.cpp::showInstance() | "
                    << "view raw events within date range list"
                    << endl;
 
      TQDate dt;
      for ( dt = m_variables->getStartDateTime().date();
                dt <= m_variables->getEndDateTime().date() && status != false;
                dt = dt.addDays(1) ) {
        Event::List events =
              m_variables->getCalendar()->events( dt,
                                                  EventSortStartDate,
                                                  SortDirectionAscending );
        status = printEventList( &ts, &events, dt );
      }
    }
      } else {
    TQDate firstdate, lastdate;
    if ( m_variables->getAll() ) {
      kdDebug() << "konsolekalendar.cpp::showInstance() | "
                    << "HTML view all events sorted list"
                    << endl;
          // sort the events for this date by start date
          // in order to determine the date range.
          Event::List *events =
            new Event::List ( m_variables->getCalendar()->rawEvents(
                                EventSortStartDate,
                                SortDirectionAscending ) );
      firstdate = events->first()->dtStart().date();
      lastdate = events->last()->dtStart().date();
    } else if ( m_variables->isUID() ) {
      // TODO
      kdDebug() << "konsolekalendar.cpp::showInstance() | "
                    << "HTML view events by uid list" << endl;
      cout << i18n("Sorry, export to HTML by UID is not supported yet")
            .local8Bit().data() << endl;
      return( false );
    } else {
      kdDebug() << "konsolekalendar.cpp::showInstance() | "
                    << "HTML view raw events within date range list"
                    << endl;
      firstdate = m_variables->getStartDateTime().date();
      lastdate = m_variables->getEndDateTime().date();
    }
 
        HTMLExportSettings htmlSettings( "Konsolekalendar" );
 
        //TODO: get progname and url from the values set in main
        htmlSettings.setCreditName( "KonsoleKalendar" );
        htmlSettings.setCreditURL( "http://pim.kde.org/components/konsolekalendar.php" );
 
        htmlSettings.setExcludePrivate( true );
        htmlSettings.setExcludeConfidential( true );
 
        htmlSettings.setEventView( false );
        htmlSettings.setMonthView( false );
        if ( m_variables->getExportType() == ExportTypeMonthHTML ) {
          title = i18n( "Events:" );
          htmlSettings.setMonthView( true );
        } else {
          if ( firstdate == lastdate ) {
            title = i18n( "Events: %1" )
                    .arg(  firstdate.toString( TQt::TextDate ) );
          } else {
            title = i18n( "Events: %1 - %2" )
                    .arg( firstdate.toString( TQt::TextDate ) )
                    .arg( lastdate.toString( TQt::TextDate ) );
          }
          htmlSettings.setEventView( true );
        }
        htmlSettings.setEventTitle( title );
        htmlSettings.setEventAttendees( true );
// Not supporting Todos yet
//         title = "To-Do List for " + firstdate.toString(TQt::TextDate);
//         if ( firstdate != lastdate ) {
//           title += " - " + lastdate.toString(TQt::TextDate);
//         }
        htmlSettings.setTodoListTitle( title );
        htmlSettings.setTodoView( false );
//         htmlSettings.setTaskCategories( false );
//         htmlSettings.setTaskAttendees( false );
//         htmlSettings.setTaskDueDate( true );
 
        htmlSettings.setDateStart( TQDateTime( firstdate ) );
        htmlSettings.setDateEnd( TQDateTime( lastdate ) ) ;
 
        KCal::HtmlExport *Export;
        Export = new HtmlExport( m_variables->getCalendar(), &htmlSettings );
    status = Export->save( &ts );
        delete Export;
      }
      f.close();
    }
  }
  return status;
}
 
bool KonsoleKalendar::printEventList( TQTextStream *ts,
                                      Event::List *eventList, TQDate date )
{
  bool status = true;
 
  if ( eventList->count() ) {
    Event *singleEvent;
    Event::List::ConstIterator it;
 
    for ( it = eventList->begin();
          it != eventList->end() && status != false;
          ++it ) {
      singleEvent = *it;
 
      status = printEvent( ts, singleEvent, date );
    }
  }
 
  return( status );
}
 
bool KonsoleKalendar::printEvent( TQTextStream *ts, Event *event, TQDate dt )
{
  bool status = false;
  bool sameDay = true;
  KonsoleKalendarExports exports;
 
  if ( event ) {
    switch ( m_variables->getExportType() ) {
 
    case ExportTypeCSV:
      kdDebug() << "konsolekalendar.cpp::printEvent() | "
                << "CSV export"
                << endl;
      status = exports.exportAsCSV( ts, event, dt );
      break;
 
    case ExportTypeTextShort:
      kdDebug()
        << "konsolekalendar.cpp::printEvent() | "
        << "TEXT-SHORT export"
        << endl;
      if ( dt.daysTo( m_saveDate ) ) {
        sameDay = false;
        m_saveDate = dt;
      }
      status = exports.exportAsTxtShort( ts, event, dt, sameDay );
      break;
 
    case ExportTypeHTML:
      // this is handled separately for now
      break;
 
    default:// Default export-type is ExportTypeText
      kdDebug() << "konsolekalendar.cpp::printEvent() | "
                << "TEXT export"
                << endl;
      status = exports.exportAsTxt( ts, event, dt );
      break;
    }
  }
  return( status );
}
 
bool KonsoleKalendar::addEvent()
{
  kdDebug() << "konsolecalendar.cpp::addEvent() | "
            << "Create Adding"
            << endl;
  KonsoleKalendarAdd add( m_variables );
  kdDebug() << "konsolecalendar.cpp::addEvent() | "
            << "Adding Event now!"
            << endl;
  return( add.addEvent() );
}
 
bool KonsoleKalendar::changeEvent()
{
 
  kdDebug() << "konsolecalendar.cpp::changeEvent() | "
            << "Create Changing"
            << endl;
  KonsoleKalendarChange change( m_variables );
  kdDebug() << "konsolecalendar.cpp::changeEvent() | "
            << "Changing Event now!"
            << endl;
  return( change.changeEvent() );
}
 
bool KonsoleKalendar::deleteEvent()
{
  kdDebug() << "konsolecalendar.cpp::deleteEvent() | "
            << "Create Deleting"
            << endl;
  KonsoleKalendarDelete del( m_variables );
  kdDebug() << "konsolecalendar.cpp::deleteEvent() | "
            << "Deleting Event now!"
            << endl;
  return( del.deleteEvent() );
}
 
bool KonsoleKalendar::isEvent( TQDateTime startdate,
                               TQDateTime enddate, TQString summary )
{
  // Search for an event with specified start and end datetime stamp and summary
 
  Event *event;
  Event::List::ConstIterator it;
 
  bool found = false;
 
  Event::List eventList( m_variables->getCalendar()->
                         rawEventsForDate( startdate.date(),
                                           EventSortStartDate,
                                           SortDirectionAscending ) );
  for ( it = eventList.begin(); it != eventList.end(); ++it ) {
    event = *it;
    if ( event->dtEnd() == enddate && event->summary() == summary ) {
      found = true;
      break;
    }
  }
  return found;
}
 
void KonsoleKalendar::printSpecs()
{
  cout << i18n( "  What:  %1" ).
    arg( m_variables->getSummary() ).local8Bit().data()
       << endl;
 
  cout << i18n( "  Begin: %1" ).
    arg( m_variables->getStartDateTime().toString( TQt::TextDate ) ).local8Bit().data()
       << endl;
 
  cout << i18n( "  End:   %1" ).
    arg( m_variables->getEndDateTime().toString( TQt::TextDate ) ).local8Bit().data()
       << endl;
 
  if ( m_variables->getFloating() == true ) {
    cout << i18n( "  No Time Associated with Event" ).local8Bit().data()
         << endl;
  }
 
  cout << i18n( "  Desc:  %1" ).
    arg( m_variables->getDescription() ).local8Bit().data()
       << endl;
 
  cout << i18n( "  Location:  %1" ).
    arg( m_variables->getLocation() ).local8Bit().data()
       << endl;
}