void TasksView::addTaskHelper( const Task& parent )
{
ViewFilter* filter = Application::instance().model().taskModel();
Task task;
int suggestedId = parent.isValid() ? parent.id() : 1;
if ( parent.isValid() ) {
task.setParent( parent.id() );
// subscribe if the parent is subscribed:
task.setSubscribed( parent.subscribed()
|| CONFIGURATION.taskPrefilteringMode == Configuration::TaskPrefilter_SubscribedOnly
|| CONFIGURATION.taskPrefilteringMode == Configuration::TaskPrefilter_SubscribedAndCurrentOnly );
}
// yeah, daredevil!
while ( filter->taskIdExists( suggestedId ) ) ++suggestedId;
TaskIdDialog dialog( filter, this );
dialog.setSuggestedId( suggestedId );
if ( dialog.exec() ) {
task.setId( dialog.selectedId() );
task.setName( dialog.taskName() );
CommandAddTask* cmd = new CommandAddTask( task, this );
emit emitCommand( cmd );
if ( parent.isValid() ) {
const QModelIndex parentIdx = filter->indexForTaskId( parent.id() );
m_treeView->setExpanded( parentIdx, true );
}
}
}
void SqLiteStorageTests::deleteTaskWithEventsTest()
{
// make a task
const int TaskId = 1;
const QString Task1Name( "Task-Name" );
Task task;
task.setId( TaskId );
task.setName( Task1Name );
task.setValidFrom( QDateTime::currentDateTime() );
QVERIFY( m_storage->deleteAllTasks() );
QVERIFY( m_storage->deleteAllEvents() );
QVERIFY( m_storage->getAllTasks().size() == 0 );
QVERIFY( m_storage->addTask( task ) );
QVERIFY( m_storage->getAllTasks().size() == 1 );
Task task2;
task2.setId( 2 );
task2.setName( "Task-2-Name" );
QVERIFY( m_storage->addTask( task2 ) );
QVERIFY( m_storage->getAllTasks().size() == 2 );
// create 3 events, 2 for task 1, and one for another one
{
Event event = m_storage->makeEvent();
QVERIFY( event.isValid() );
event.setTaskId( task.id() );
event.setUserId( 1 );
event.setReportId( 42 );
const QString EventComment( "Event-Comment" );
event.setComment( EventComment );
QVERIFY( m_storage->modifyEvent( event ) );
}
{
Event event = m_storage->makeEvent();
QVERIFY( event.isValid() );
event.setTaskId( task.id() );
event.setUserId( 1 );
event.setReportId( 43 );
const QString EventComment( "Event-Comment 2" );
event.setComment( EventComment );
QVERIFY( m_storage->modifyEvent( event ) );
}
// this is the event that is supposed to remain in the DB:
Event event = m_storage->makeEvent();
QVERIFY( event.isValid() );
event.setTaskId( task2.id() );
event.setUserId( 1 );
event.setReportId( 43 );
const QString EventComment( "Event-Comment 2" );
event.setComment( EventComment );
QVERIFY( m_storage->modifyEvent( event ) );
// verify task database entries
QVERIFY( m_storage->deleteTask( task ) );
EventList events = m_storage->getAllEvents();
QVERIFY( events.count() == 1 );
QVERIFY( events.first() == event );
}
// this test more or less documents the behaviour of the mysql driver which allows nested transactions, which fail, without
// reporting an error
void SqlTransactionTests::testMySqlNestedTransactions()
{
MySqlStorage storage = prepareMySqlStorage();
QVERIFY( storage.database().open() );
QList<Task> tasksBefore = storage.getAllTasks();
QVERIFY( ! tasksBefore.isEmpty() );
Task first = tasksBefore.takeFirst();
// test a simple transaction that is completed and committed:
{
SqlRaiiTransactor transactor( storage.database() );
QSqlQuery query( storage.database() );
query.prepare("DELETE from Tasks where id=:id");
query.bindValue( "id", first.id() );
QVERIFY( storage.runQuery( query ) );
{ // now before the first transaction is commited and done, a second one is started
// this should throw an exception
SqlRaiiTransactor transactor2( storage.database() );
QSqlError error = storage.database().lastError();
// QFAIL( "I should not get here." );
transactor2.commit();
}
QSqlError error1 = storage.database().lastError();
transactor.commit();
QSqlError error2 = storage.database().lastError();
QFAIL( "I should not get here." );
}
}
void SmartNameCache::deleteTask( const Task& task )
{
const TaskList::Iterator it = qBinaryFind( m_tasks.begin(), m_tasks.end(), Task( task.id(), QString() ), IdLessThan() );
if ( it != m_tasks.constEnd() ) {
m_tasks.erase( it );
regenerateSmartNames();
}
}
void SmartNameCache::modifyTask( const Task& task )
{
const TaskList::Iterator it = qBinaryFind( m_tasks.begin(), m_tasks.end(), Task( task.id(), QString() ), IdLessThan() );
if ( it != m_tasks.constEnd() )
*it = task;
sortTasks();
regenerateSmartNames();
}
bool Task::operator==(const Task& task) const {
if ((*task.project() == *_project)
&& (task.id()->compare(*_id) == 0)) {
return true;
} else {
return false;
}
}
// try to restore subscriptions where possible
Q_FOREACH( const Task& oldTask, oldTasks ) {
const Task task = getTask( oldTask.id() );
if ( task.isValid() ) {
if ( oldTask.subscribed() ) {
addSubscription( user, task );
}
}
}
void SqLiteStorageTests::makeModifyDeleteEventsTest()
{
// make a user
User user = m_storage->makeUser( tr("MakeEventTestUser") );
// make two events
Task task = m_storage->getTask( 1 );
// WARNING: depends on leftover task created in previous test
QVERIFY( task.isValid() );
Event event1 = m_storage->makeEvent();
QVERIFY( event1.isValid() );
event1.setTaskId( task.id() );
event1.setUserId( user.id() );
event1.setReportId( 42 );
const QString Event1Comment( "Event-1-Comment" );
event1.setComment( Event1Comment );
Event event2 = m_storage->makeEvent();
QVERIFY( event2.isValid() );
event2.setTaskId( task.id() );
event2.setUserId( user.id() );
const QString Event2Comment( "Event-2-Comment" );
event2.setComment( Event2Comment );
QVERIFY( event1.id() != event2.id() );
// modify the events
QVERIFY( m_storage->modifyEvent( event1 ) ); // store new name
QVERIFY( m_storage->modifyEvent( event2 ) ); // -"-
// verify event database entries
Event event1_1 = m_storage->getEvent( event1.id() );
QCOMPARE( event1_1.comment(), event1.comment() );
Event event2_1 = m_storage->getEvent( event2.id() );
QCOMPARE( event2_1.comment(), event2.comment() );
// delete one event
QVERIFY( m_storage->deleteEvent( event1 ) );
// verify the event is gone:
QVERIFY( ! m_storage->getEvent( event1.id() ).isValid() );
// verify the other event is still there:
QVERIFY( m_storage->getEvent( event2.id() ).isValid() );
}
void SubCommandLine::receive(Task task)
{
// TODO: Use QThread here
// TODO: Replace _prompt_id with an abstract method
_prompt_id = _curr_task_id = task.id();
respond(task.command());
}
bool isIndirectParent( const Task& p, const Task& c )
{
if ( c.parent() == p.id() ) return true;
if ( c.parent() == 0 ) return false;
if ( p.parent() == 0 ) return false;
const TaskTreeItem& item = DATAMODEL->taskTreeItem( p.parent() );
return isIndirectParent( item.task(), p );
}
void
TaskList::add(Task task)
{
if (XmlData::invalidId == task.id()) {
// Counting starts at zero, thus the current size is the currently highest id
// plus one.
task.setId(size());
appendChild(task);
}
}
bool Task::operator == ( const Task& other ) const
{
return other.id() == id()
&& other.parent() == parent()
&& other.name() == name()
&& other.subscribed() == subscribed()
&& other.m_trackable == m_trackable
&& other.validFrom() == validFrom()
&& other.validUntil() == validUntil();
}
void SelectTaskDialog::slotCurrentItemChanged( const QModelIndex& first,
const QModelIndex& )
{
if ( isValidAndTrackable( first ) ) {
const Task task = m_proxy.taskForIndex( first );
m_selectedTask = task.id();
} else {
m_selectedTask = 0;
}
m_ui->buttonBox->button( QDialogButtonBox::Ok )->setEnabled( m_selectedTask != 0 );
}
void ProjectWriter::writeTask(const Task &task) {
_outStream->writeChars(task.id()->c_str(), task.id()->length());
_outStream->writeString(task.shortDescription());
_outStream->writeString(task.longDescription());
char* startDate = task.startDate()->toChar();
_outStream->writeChars(startDate, strlen(startDate));
char* endDate = task.endDate()->toChar();
_outStream->writeChars(endDate, strlen(endDate));
char* duration = task.duration().toChar();
_outStream->writeChars(duration, strlen(duration));
_outStream->writeString(task.status());
_outStream->writeString(task.templateName());
vector<TaskLog*>* logs = task.logs();
_outStream->writeInt(logs->size());
for (vector<TaskLog*>::iterator iter = logs->begin(); iter != logs->end(); iter++) {
TaskLog* log = *iter;
writeTaskLog(*log);
}
}
bool Controller::deleteTask( const Task& task )
{
qDebug() << Q_FUNC_INFO << "deleting task" << task.id();
if ( m_storage->deleteTask( task ) ) {
m_storage->deleteSubscription( CONFIGURATION.user, task );
emit taskDeleted( task );
return true;
} else {
Q_ASSERT( false ); // impossible
return false;
}
}
Event Controller::makeEvent( const Task& task )
{
Event event = m_storage->makeEvent();
Q_ASSERT( event.isValid() );
event.setTaskId( task.id() );
if ( m_storage->modifyEvent( event ) ) {
emit eventAdded( event );
} else {
event = Event();
}
return event;
}
void ControllerTests::slotTaskUpdated( const Task& task )
{
int i;
for ( i = 0; i < m_definedTasks.size(); ++i )
{
if ( m_definedTasks[i].id() == task.id() ) {
m_definedTasks[i] = task;
break;
}
}
// it is a failure if we receive the signal for nonexisting tasks
QVERIFY( i != m_definedTasks.size() );
}
bool Controller::addTask( const Task& task )
{
qDebug() << Q_FUNC_INFO << "adding task" << task.id()
<< "to parent" << task.parent();
if ( m_storage->addTask( task ) ) {
updateSubscriptionForTask( task );
emit taskAdded( task );
return true;
} else {
Q_ASSERT( false ); // impossible
return false;
}
}
void ControllerTests::slotTaskDeleted( const Task& task )
{
// task.dump();
int i;
for ( i = 0; i < m_definedTasks.size(); ++i )
{
if ( m_definedTasks[i].id() == task.id() ) {
m_definedTasks.removeAt( i );
return;
}
}
// it is a failure if we receive the signal for nonexisting tasks
QVERIFY( i != m_definedTasks.size() ); // always true, give more
// feedback
}
string* Task::nextChildId() {
vector<Task*> tasks = children();
int lastId = 0;
for (vector<Task*>::iterator iter = tasks.begin(); iter != tasks.end(); iter++) {
Task* sub = *iter;
const char* id = sub->id()->c_str();
id = strrchr(id, '.') + 1;
int subId = atoi(id);
if (subId > lastId) {
lastId = subId;
}
}
stringstream ss;
lastId++;
ss << *id() << "." << lastId;
return new string(ss.str());
}
bool Controller::modifyTask( const Task& task )
{
// find it
qDebug() << Q_FUNC_INFO << "committing changes to task"
<< task.id();
// modify the task itself:
bool result = m_storage->modifyTask( task );
Q_ASSERT( result );
if ( ! result ) {
qDebug() << Q_FUNC_INFO << "modifyTask failed!";
return result;
}
updateSubscriptionForTask( task );
emit( taskUpdated( task ) );
return true;
}
bool DownloadManager::startTask(Task task)
{
LOG(0, "enter DownloadManager::startTask, task = %p\n", task.info_);
if (std::find(d->tasks.begin(), d->tasks.end(), task.info_) != d->tasks.end())
{
if ( (task.info_->state == TASK_FINISH) || (task.info_->state == TASK_DOWNLOAD) )
{
LOG(0, "task %p state is %d, can't start\n", task.id(), task.info_->state);
return false;
}
task.info_->protocol->addTask(task.info_);
task.info_->state = TASK_DOWNLOAD;
return true;
}
return false;
}
bool DownloadManager::stopTask(Task task)
{
LOG(0, "enter DownloadManager::stopTask, task = %p\n", task.info_);
if (std::find(d->tasks.begin(), d->tasks.end(), task.info_) != d->tasks.end())
{
if (task.info_->state != TASK_DOWNLOAD)
{
LOG(0, "task %p state is %d, can't stop\n", task.id(), task.info_->state);
return false;
}
task.info_->protocol->flushTask(task.info_);
task.info_->state = TASK_WAIT;
return true;
}
return false;
}
void SqlTransactionTests::testMySqlTransactionCommit()
{
MySqlStorage storage = prepareMySqlStorage();
QVERIFY( storage.database().open() );
QList<Task> tasksBefore = storage.getAllTasks();
QVERIFY( ! tasksBefore.isEmpty() );
Task first = tasksBefore.takeFirst();
// test a simple transaction that is completed and committed:
{
SqlRaiiTransactor transactor( storage.database() );
QSqlQuery query( storage.database() );
query.prepare("DELETE from Tasks where id=:id");
query.bindValue( "id", first.id() );
QVERIFY( storage.runQuery( query ) );
transactor.commit();
} // this transaction WAS commited
QList<Task> tasksAfter = storage.getAllTasks();
QVERIFY( ! tasksAfter.isEmpty() );
QVERIFY( tasksBefore == tasksAfter );
}
void TaskEditor::setTask( const Task& task )
{
Q_ASSERT( m_ui );
m_task = task;
const TaskTreeItem& taskTreeItem =
MODEL.charmDataModel()->taskTreeItem( task.id() );
m_ui->labelTaskName->setText( MODEL.charmDataModel()->fullTaskName( taskTreeItem.task() ) );
m_ui->lineEditName->setText( task.name() );
m_ui->checkBoxTrackable->setChecked( task.trackable() );
if( task.parent() != 0 ) {
const TaskTreeItem& parentItem =
MODEL.charmDataModel()->taskTreeItem( task.parent() );
const QString name = parentItem.task().name();
m_ui->pushButtonParent->setText( name );
} else {
m_ui->pushButtonParent->setText( tr( "Choose Parent Task" ) );
}
if( task.parent() == 0 ) {
m_ui->checkBoxTopLevel->setChecked( true );
} else {
m_ui->checkBoxTopLevel->setChecked( false );
}
QDate start = task.validFrom().date();
if( start.isValid() ) {
m_ui->dateEditFrom->setDate( start );
m_ui->checkBoxFrom->setChecked( false );
} else {
m_ui->checkBoxFrom->setChecked( true );
m_ui->dateEditFrom->setDate( QDate::currentDate() );
}
QDate end = task.validUntil().date();
if( end.isValid() ) {
m_ui->dateEditTo->setDate( end );
m_ui->checkBoxUntil->setChecked( false );
} else {
m_ui->checkBoxUntil->setChecked( true );
m_ui->dateEditTo->setDate( QDate::currentDate() );
}
checkInvariants();
}
bool Controller::modifyTask( const Task& task )
{
// find it
qDebug() << "Controller::modifyTask: committing changes to task"
<< task.id();
// modify the task itself:
bool result = m_storage->modifyTask( task );
Q_ASSERT( result ); Q_UNUSED( result );
if ( ! result ) {
qDebug() << "Controller::modifyTask: modifyTask failed!";
return result;
}
updateSubscriptionForTask( task );
if ( result ) {
emit( taskUpdated( task ) );
} else {
qDebug() << "Controller::modifyTask: storing subscription state failed.";
}
return result;
}
void SqlTransactionTests::testMySqlTransactionRollback()
{
MySqlStorage storage = prepareMySqlStorage();
QVERIFY( storage.database().open() );
QSqlDriver* driver = storage.database().driver();
QVERIFY( driver->hasFeature( QSqlDriver::Transactions ) );
QList<Task> tasksBefore = storage.getAllTasks();
QVERIFY( ! tasksBefore.isEmpty() );
Task first = tasksBefore.first();
// test a simple transaction that is completed and committed:
{
SqlRaiiTransactor transactor( storage.database() );
QSqlQuery query( storage.database() );
query.prepare("DELETE from Tasks where id=:id");
query.bindValue( "id", first.id() );
QVERIFY( storage.runQuery( query ) );
} // this transaction was NOT commited
QList<Task> tasksAfter = storage.getAllTasks();
QVERIFY( ! tasksAfter.isEmpty() );
QVERIFY( tasksBefore == tasksAfter );
}
bool TaskModelAdapter::taskHasChildren( const Task& task ) const
{
const TaskTreeItem& item = m_dataModel->taskTreeItem( task.id() );
return item.childCount() > 0;
}
bool TaskModelAdapter::taskIsActive( const Task& task ) const
{
Q_ASSERT( m_dataModel != 0 );
return m_dataModel->isTaskActive( task.id() );
}
bool operator()( const Task& lhs, const Task& rhs ) const
{
return lhs.id() < rhs.id();
}
