noo/client/storage.cpp

#include "storage.h"
#include <QVariant>
#include <assert.h>
#include <encryption.h>
#include <iostream>

#ifdef TARGET_WIN
# include <WinSock2.h>
#endif
enum class DbProperty
{
    Version = 1,
    InternalCipher = 2
};

#define CURRENT_DBVERSION "0"

// Function to make encryption. Input is raw content blob, output is blob with IV, original length and encrypted data.
/*static void EncryptBlob(const QByteArray& input, QByteArray& output)
{
    TwofishCipher cipher;

    // Generate 16 bytes IV
    QByteArray iv(16, 0);
    IV::Generate(iv);
    cipher.setIV(iv);

    // Make padding
    int padded = (input.length() % cipher.blocksize()) ? (cipher.blocksize() - input.length() % cipher.blocksize()) : 0;

    // Prepare output buffer
    output.resize(iv.length() + 4 + input.length() + padded);

    // Copy IV
    memcpy(output.data(), iv.data(), iv.length());

    // Copy original length in network byte order
    uint32_t lengthNbo = htonl(input.length());
    memcpy(output.data() + iv.length(), &lengthNbo, 4);

    // Encrypt
    cipher.encrypt(input, 0, output, iv.length() + 4);
}*/

/*static void DecryptBlob(const QByteArray& input, QByteArray& output)
{
    TwofishCipher cipher;
    assert(input.length() >= cipher.blocksize() + 4);

    // Read IV
    QByteArray iv(input.data(), cipher.blocksize());

    // Read original length
    uint32_t lengthNbo;
    memcpy(&lengthNbo, input.data() + iv.length(), 4);

    // Prepare output buffer
    output.resize(input.length() - iv.length() - 4);

    // Set IV
    cipher.setIV(iv);

    // Decrypt data
    cipher.decrypt(input, iv.length() + 4, output, 0);

    // Truncate to original size
    output.truncate(ntohl(lengthNbo));
}*/


Storage::Storage()
{
}

Storage::~Storage()
{
    close();
}

QString Storage::path()
{
    return mPath;
}

void Storage::setPath(const QString &path)
{
    mPath = path;
}

QString Storage::key()
{
    return mKey;
}

void Storage::setKey(const QString &key)
{
    mKey = key;
}

SQLite::Database& Storage::database()
{
    return *mDatabase;
}

bool Storage::create()
{
    assert(!mPath.isEmpty());
    try
    {
        mDatabase = QSharedPointer<SQLite::Database>(new SQLite::Database(mPath.toStdString().c_str(), SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE ));
    }
    catch(std::exception& e)
    {
        return false;
    }

#ifdef USE_ENCRYPTED_DB
    try
    {
        std::string keyQuery = "pragma key='" + mKey.toStdString() + "'";
        mDatabase->exec(keyQuery.c_str());
        mDatabase->exec("pragma locking_mode=EXCLUSIVE");
        mDatabase->exec("pragma journal_mode=MEMORY");
        mDatabase->exec("pragma temp_store=MEMORY");
    }
    catch(std::exception& e)
    {
        std::cout << e.what() << std::endl;
        return false;
    }
#endif

    try
    {
        // Synctime & timestamp are always milliseconds from the start of UNIX epoch.

        // Timeline
        mDatabase->exec("CREATE TABLE timeline ("
                        "id         INTEGER PRIMARY KEY, "
                        "removed    INTEGER, "
                        "taskid     INTEGER, "
                        "starttime  TEXT, "
                        "endtime    TEXT, "
                        "timestamp  INTEGER)");
        mDatabase->exec("CREATE INDEX timeline_taskid_index ON timeline(taskid ASC)");

        // Tasks tree
        mDatabase->exec("CREATE TABLE task ("
                        "type       INTEGER, "
                        "removed    INTEGER, "
                        "id         INTEGER PRIMARY KEY, "
                        "parentid   INTEGER, "
                        "orderid    INTEGER, "
                        "title      TEXT, "
                        "html       TEXT, "
                        "flags      INTEGER, "
                        "timestamp  INTEGER)");

        mDatabase->exec("CREATE INDEX task_parentid_index ON task(parentid ASC)");

        // Tasks history
        mDatabase->exec("CREATE TABLE history_task ("
                        "removed_old    INTEGER, "
                        "removed_new    INTEGER, "
                        "timestamp_old  INTEGER, "
                        "timestamp_new  INTEGER, "
                        "id             INTEGER PRIMARY KEY, "
                        "parent_id_old  INTEGER, "
                        "parent_id_new  INTEGER, "
                        "order_id_old   INTEGER, "
                        "order_id_new   INTEGER, "
                        "diff_title     TEXT, "
                        "diff_html      TEXT, "
                        "flags_old      INTEGER, "
                        "flags_new      INTEGER)");

        // Attachments
        mDatabase->exec("CREATE TABLE file ("
                        "id         INTEGER PRIMARY KEY, "
                        "removed    INTEGER, "
                        "taskid     INTEGER, "
                        "filename   TEXT, "
                        "content    BLOB, "
                        "orderid    INTEGER, "
                        "timestamp  INTEGER)");

        mDatabase->exec("CREATE TABLE history_file ("
                        "id             INTEGER PRIMARY KEY, "
                        "removed_old    INTEGER, "
                        "removed_new    INTEGER, "
                        "taskid_old     INTEGER, "
                        "taskid_new     INTEGER, "
                        "filename_old   TEXT, "
                        "filename_new   TEXT,"
                        "content        BLOB, "
                        "order_id_old   INTEGER, "
                        "order_id_new   INTEGER, "
                        "timestamp_old  INTEGER, "
                        "timestamp_new  INTEGER)");

        mDatabase->exec("CREATE INDEX file_taskid_index ON file(taskid ASC)");

        // Sync status
        mDatabase->exec("CREATE TABLE syncs (timestamp INT, status TEXT)");


    }
    catch(std::exception& e)
    {
        std::cerr << e.what() << std::endl;
        return false;
    }

    return true;
}

bool Storage::open()
{
    assert(!mPath.isEmpty());

    try
    {
        mDatabase = QSharedPointer<SQLite::Database>(new SQLite::Database(mPath.toStdString().c_str(), SQLITE_OPEN_READWRITE));
        mDatabase->exec("pragma key='" + mKey.toStdString() + "'");
        SQLite::Statement q(*mDatabase, "select count(*) from sqlite_master");
        if (!q.executeStep())
            return false;
        mDatabase->exec("pragma locking_mode=EXCLUSIVE");
        mDatabase->exec("pragma journal_mode=MEMORY");
        mDatabase->exec("pragma temp_store=MEMORY");

    }
    catch(std::exception& e)
    {
        std::cerr << e.what() << std::endl;
        return false;
    }

    loadTaskTree();
    return true;
}

void Storage::close()
{
    if (mDatabase)
    {
        mDatabase.clear();
    }
}

bool Storage::hasTable(const QString& tablename)
{
    SQLite::Statement tableQuery(*mDatabase, "SELECT name FROM sqlite_master WHERE type='table' AND name=:tablename");
    tableQuery.bind(":tablename", tablename.toStdString());
    return tableQuery.executeStep();
}

bool Storage::upgrade()
{
    int currentVersion = 0;

    // Check if properties table is here
    if (!mDatabase)
        return false;

    if (!hasTable("properties"))
    {
        // If not - create it and consider database version 0
        SQLite::Statement createQuery(*mDatabase, "create table properties(type INTEGER, value TEXT)");
        if (!createQuery.exec())
            return false;

        // Insert version 0
        SQLite::Statement insertVersionQuery(*mDatabase, "insert into properties(type, value) values(:proptype, :proptext)");
        insertVersionQuery.bind(":proptype", (int)DbProperty::Version);
        insertVersionQuery.bind(":proptext", "0");
    }
    else
    {
        // If yes - get database version from 'dbversion' key
        SQLite::Statement versionQuery(*mDatabase, "select value from properties where type=:proptype");
        versionQuery.bind(":proptype", (int)DbProperty::Version);
        if (!versionQuery.executeStep())
            return false;

        QString dbVersionText = versionQuery.getColumn(0).getText("");
        if (dbVersionText.isEmpty())
            return false;

        bool ok = false;
        currentVersion = dbVersionText.toInt(&ok);
        if (!ok)
            return false;
    }

    // Depending on obtained version upgrade database
    switch (currentVersion)
    {
    case 0:
        if (!upgradeFromVersion0())
            return false;
        break;
    }

    // Update version number after upgrade
    SQLite::Statement updateVersion(*mDatabase, "update table properties set value=:proptext where type=:proptype");
    updateVersion.bind(":proptext", CURRENT_DBVERSION);
    updateVersion.bind(":proptype", (int)DbProperty::Version);
    updateVersion.exec();

    return true;
}

bool Storage::upgradeFromVersion0()
{
    /*
  // Upgrade tasks table
  SQLite::Statement addEncryptedTitle(*mDatabase, "alter table task add column title_encrypted BLOB");
  if (!addEncryptedTitle.exec())
    return false;

  SQLite::Statement addEncryptedContent(*mDatabase, "alter table task add column content_encrypted BLOB");
  if (!addEncryptedContent.exec())
    return false;

  SQLite::Statement addEncryptedAttachments(*mDatabase, "alter table attachment add column content_encrypted BLOB");
  if (!addEncryptedAttachments.exec())
    return false;

  // Database scheme is upgraded here, convert the data

  SQLite::Statement tasks(*mDatabase, "select id, title, html from task");
  while (tasks.executeStep())
  {
    // TODO
  }
  // Iterate all notes and attachments and make them Twofish encrypted
  mTaskToUpgrade.resize(topOfTaskTree().size());
  std::copy(topOfTaskTree().begin(), topOfTaskTree().end(), mTaskToUpgrade);
  for (PTask task: mTaskToUpgrade)
  {
    encryptTaskContent(task);
    //encryptTaskAttachment(task);

    // Add children to list
    int tl = mTaskToUpgrade.length();
    mTaskToUpgrade.resize(mTaskToUpgrade.size() + task->children().size());
    std::copy(task->children().begin(), task->children().end(), mTaskToUpgrade.begin() + tl);
  }
  */
    return true;
}

bool Storage::encryptTask(PTask /*task*/)
{
    return false;
}

bool Storage::encryptTaskContent(PTask /*task*/)
{
    return false;
}

bool Storage::encryptTaskAttachment(PAttachment /*attachment*/)
{
    return false;
}


PTask Storage::createTask(int index)
{
    if (!mDatabase)
        return PTask();

    SQLite::Statement insertQuery(*mDatabase, "insert into task(id, title, html, parentid, orderid, type, flags) values(NULL, :title, :html, NULL, :orderid, 0, 0)");
    insertQuery.bind(":title", "");
    insertQuery.bind(":html", "");
    insertQuery.bind(":orderid", index);
    if (insertQuery.exec())
    {
        PTask result(new Task());
        result->setId(database().getLastInsertRowid())
               .setIndex(index);

        mTaskModelIdMap[result->modelId()] = result;
        mTaskIdMap[result->id()] = result;
        if (index > mTopTasks.size())
            mTopTasks.push_back(result);
        else
        {
            mTopTasks.insert(mTopTasks.begin() + index, result);
            // Assign new indexes for top tasks
            for (int i=0; i<mTopTasks.size(); i++)
            {
                mTopTasks[i]->setIndex(i)
                             .save();
            }
        }
        return result;
    }
    else
        return PTask();
}

PTask Storage::createTask(const PTask& parent, int index)
{
    if (!parent)
        return createTask(index);
    if (!mDatabase)
        return PTask();

    SQLite::Statement insertQuery(database(), "insert into task(id, title, html, parentid, orderid, type, flags) values(NULL, :title, :html, :parentid, :orderid, 0, 0)");
    insertQuery.bind(":title", "");
    insertQuery.bind(":html", "");
    insertQuery.bind(":parentid", (sqlite3_int64)parent->id());
    insertQuery.bind(":orderid", index);
    if (insertQuery.exec())
    {
        PTask result(new Task());
        result->setId(database().getLastInsertRowid());
        result->setIndex(index);
        result->setParent(parent);
        if (index > parent->children().size())
            parent->children().push_back(result);
        else
        {
            parent->children().insert(parent->children().begin() + index, result);
            for (int i=0; i<parent->children().size(); i++)
            {
                parent->children()[i]->setIndex(i)
                                      .save();
            }
        }

        mTaskModelIdMap[result->modelId()] = result;
        mTaskIdMap[result->id()] = result;
        return result;
    }
    return PTask();
}
/*
PTask Storage::loadTask(Task::Id id, PTask parent)
{
  PTask result(new Task());
  result->setId(id);
  result->load();
  result->setParent(parent);
  mTaskIdMap[result->modelId()] = result;

  return result;
}
*/

void Storage::saveTask(PTask task, Depth depth)
{
    if (depth == depthSingleTask)
        saveSingleTask(task);
    else
    {
        saveSingleTask(task);
        TaskArray& children = task->children();
        foreach(PTask child, children)
            saveTask(child, depthRecursive);
    }
}

bool Storage::moveTask(PTask task, PTask newParent, int indexToInsert)
{
    bool result = false;
    task->setParent(newParent);
    if (newParent)
    {
        SQLite::Statement updateParent(database(), "update task set parentid=:parentid where id=:id");
        updateParent.bind(":parentid", (sqlite3_int64)newParent->id());
        updateParent.bind(":id", (sqlite3_int64)task->id());
        result = updateParent.exec();

        // Insert into children list
        TaskArray& children = newParent->children();
        if (indexToInsert >= children.size())
            children.push_back(task);
        else
            children.insert(indexToInsert, task);
        for (int i=0; i<children.size(); i++)
        {
            children[i]->setIndex(i);
            children[i]->save();
        }
    }
    else
    {
        SQLite::Statement updateToRoot(database(), "update task set parentid = NULL where id=:id");
        updateToRoot.bind(":id", (sqlite3_int64)task->id());
        result = updateToRoot.exec();
        if (result)
            task->setParentId(0);

        // Insert into root list
        if (topOfTaskTree().size() > indexToInsert)
            topOfTaskTree().insert(indexToInsert, task);
        else
            topOfTaskTree().push_back(task);

        for (int i=0; i<topOfTaskTree().size(); i++)
        {
            topOfTaskTree()[i]->setIndex(i)
                               .save();
        }
    }

    if (result)
    {
        task->save();
    }

    return result;
}

bool Storage::isOpened()
{
    return mDatabase != nullptr;
}

void Storage::save()
{
    foreach (PTask task, mTopTasks)
        saveTask(task, depthRecursive);

    database().exec("delete from task where removed = 1");
    database().exec("delete from timeline where removed = 1");
    database().exec("delete from file where removed = 1");
    //database().exec("delete from change where removed = 1");
}

void Storage::saveSingleTask(PTask task)
{
    task->save();
}

void Storage::loadTaskRecord(Task& t, SQLite::Statement& q)
{
    t.mId               = q.getColumn(0).getInt64();
    t.mTitle            = q.getColumn(1).getText();
    t.mIndex            = q.getColumn(2).getInt();
    t.mFlags            = q.getColumn(3).getInt();
    t.mAttachmentCount  = q.getColumn(4).getInt();
}

void Storage::loadTaskTree()
{
    mTopTasks.clear();

    SQLite::Statement q(database(), "select id, title, orderid, flags, (select count(*) from file where (file.taskid = task.id) and ((file.removed is null) or (file.removed = 0))) from task where (parentid is null) and ((removed != 1) or (removed is null)) order by orderid");
    int currentIndex = 0;
    while(q.executeStep())
    {
        PTask t(new Task());
        loadTaskRecord(*t, q);
        t->setIndex(currentIndex++);
        mTaskModelIdMap[t->modelId()] = t;
        mTaskIdMap[t->id()] = t;
        mTopTasks.push_back(t);
    }

    foreach (PTask task, mTopTasks)
        loadTaskChildren(task);
}

void Storage::loadTaskChildren(PTask task)
{
    SQLite::Statement q(database(), "select id, title, orderid, flags, (select count(*) from file where (file.taskid = task.id) and ((file.removed is null) or (file.removed = 0))) from task where (task.parentid = :parentid) and ((task.removed != 1) or (task.removed is null)) order by task.orderid");
    q.bind(":parentid", (sqlite3_int64)task->id());
    int currentIndex = 0;
    while (q.executeStep())
    {
        PTask t(new Task());
        loadTaskRecord(*t, q);
        t->setIndex(currentIndex++)
          .setParent(task, false);

        loadTaskChildren(t);
        mTaskModelIdMap[t->modelId()] = t;
        mTaskIdMap[t->id()] = t;
        task->children().push_back(t);
    }
}

PTask Storage::findTaskByModelId(Task::ModelId id)
{
    auto taskIter = mTaskModelIdMap.find(id);
    if (taskIter != mTaskModelIdMap.end())
        return *taskIter;
    else
        return PTask();
}

PTask Storage::findTaskById(Task::Id id)
{
    auto taskIter = mTaskIdMap.find(id);
    if (taskIter != mTaskIdMap.end())
        return *taskIter;
    else
        return PTask();
}

int Storage::findTaskIndexInParent(PTask task)
{
    if (task->parent())
        return task->parent()->children().indexOf(task);
    else
        return topOfTaskTree().indexOf(task);
}

TaskArray& Storage::topOfTaskTree()
{
    return mTopTasks;
}

void Storage::loadAttachments(PTask task, AttachmentArray& output)
{
    SQLite::Statement q(database(), "select id, filename, orderid from file where (taskid = :taskid) and ((removed != 1) or (removed is null)) order by orderid");
    q.bind(":taskid", (sqlite3_int64)task->id());
    while (q.executeStep())
    {
        PAttachment att(new Attachment());
        att->setId(q.getColumn(0).getInt64())
            .setFilename(q.getColumn(1).getText())
            .setTaskId(task->id())
            .setIndex(q.getColumn(2).getInt());
        output.push_back(att);
    }
}

void Storage::deleteAttachment(PAttachment att)
{
    SQLite::Statement q(database(), "update file set removed=1 where id=:id");
    q.bind(":id", (sqlite3_int64)att->id());
    q.exec();
}

void Storage::undeleteAttachment(PAttachment att)
{
    SQLite::Statement q(database(), "update file set removed=0 where id=:id");
    q.bind(":id", (sqlite3_int64)att->id());
    q.exec();
}

Id Storage::saveMetadata(const Attachment &a)
{
    if (a.mId)
    {
        SQLite::Statement q(Storage::instance().database(), "update file set filename = :filename, orderid = :orderid where id = :id");
        q.bind(":filename", a.mFilename.toStdString().c_str());
        q.bind(":orderid", a.mIndex);
        q.bind(":id", (sqlite3_int64)a.mId);

        if (q.exec())
            return a.mId;
    }
    else
    {
        SQLite::Statement q(Storage::instance().database(), "insert into file (filename, taskid, orderid, removed) values(:filename, :taskid, :orderid, 0)");
        q.bind(":filename", a.mFilename.toStdString().c_str());
        q.bind(":taskid", (sqlite3_int64)a.mTaskId);
        q.bind(":orderid", a.mIndex);
        if (q.exec())
        {
            return Storage::instance().database().getLastInsertRowid();
        }
    }

    return Id(0);
}

void Storage::saveContent(const Attachment &a, const QByteArray& content)
{
    SQLite::Statement q(Storage::instance().database(), "update file set content = :content where id = :id");
    q.bind(":content", content.data(), content.size());
    q.bind(":id", (sqlite3_int64)a.mId);
    if (q.exec())
        ;
}

QByteArray Storage::loadContent(const Attachment &a)
{
    SQLite::Statement q(Storage::instance().database(), "select content from file where id = :id");
    q.bind(":id", (sqlite3_int64)a.mId);
    if (q.executeStep())
        return QByteArray((const char*)q.getColumn(0).getBlob(), q.getColumn(0).size());
    else
        return QByteArray();
}

Id Storage::saveTimeRecord(const TimeRecord &r)
{
    if (!r.id())
    {
        SQLite::Statement q(Storage::instance().database(), "insert into timeline(id, starttime, endtime, taskid, removed) values (NULL, :starttime, :endtime, :taskid, :removed)");

        q.bind(":starttime", helper::chrono::timeToStr(r.startTime()));
        q.bind(":endtime", helper::chrono::timeToStr(r.endTime()));
        q.bind(":taskid", static_cast<sqlite3_int64>(r.taskId()));
        q.bind(":removed", 0);
        if (q.exec())
            return Storage::instance().database().getLastInsertRowid();
    }
    else
    {
        SQLite::Statement q(Storage::instance().database(),
                            "update timeline set starttime = :starttime, endtime = :endtime, taskid = :taskid, removed = 0 where id = :id");
        q.bind(":starttime", helper::chrono::timeToStr(r.startTime()));
        q.bind(":endtime", helper::chrono::timeToStr(r.endTime()));
        q.bind(":taskid", static_cast<sqlite3_int64>(r.taskId()));
        q.bind(":id", static_cast<sqlite3_int64>(r.id()));
        if (q.exec())
            return r.id();
    }
    return (Id)0;
}

void Storage::deleteTimeRecord(const TimeRecord &r)
{
    SQLite::Statement q(Storage::instance().database(), "update timeline set removed = 1 where id = :id");
    q.bind(":id", static_cast<sqlite3_int64>(r.id()));
    q.exec();
}

void Storage::loadTimeLine(TimeLine& l)
{
    SQLite::Statement q(Storage::instance().database(), "select id, starttime, endtime from timeline where (taskid = :taskid) and ((removed is null) or (removed != 1)) order by id asc");
    q.bind(":taskid", static_cast<sqlite3_int64>(l.taskId()));
    while (q.executeStep())
    {
        time_t start = helper::chrono::strToTime(q.getColumn(1).getText());
        time_t stop = helper::chrono::strToTime(q.getColumn(2).getText());

        TimeRecord tr;
        tr.setId(q.getColumn(0).getInt64())
          .setStartTime(start)
          .setEndTime(stop)
          .setTaskId(l.taskId());
        l.data().push_back(tr);
    }

    // Sort time intervals
    l.sortData();

    // Find current total time length
    l.mTotalTime = l.findTotalTime();
}

void Storage::saveTimeLime(const TimeLine& l)
{

}

Storage& Storage::instance()
{
    static Storage _instance;
    return _instance;
}


void Storage::deleteTask(const PTask& task, DeleteOption option)
{
    if (option != DeleteOption_FromParent)
    {
        // Remove from hash
        removeTask(task);
    }

    TaskArray& siblings = task->parent() ? task->parent()->children() : mTopTasks;
    siblings.removeOne(task);

    // Remove from database
    if (option == DeleteOption_Total)
    {
        SQLite::Statement q(database(), "update task set removed = 1 where id = :id");
        q.bind(":id", (sqlite3_int64)task->id());
        q.exec();
    }

#if 0
    int taskIndex = -1;
    // Update indexes
    for (int i=0; i<siblings.size(); i++)
    {
        if (siblings[i] == task)
            taskIndex = i;

        Task& t = *siblings[i];
        if (t.index() > task->index())
        {
            t.setIndex(t.index() - 1);
            t.save();
        }
    }

    // Remove from tree
    if (taskIndex >= 0)
        siblings.remove(taskIndex);
#endif
}

void Storage::undeleteTask(const PTask& task)
{
    SQLite::Statement q(database(), "update task set removed = 0 where id = :id");
    q.bind(":id", (sqlite3_int64)task->id());
    q.exec();

    // Find place where to insert task
    TaskArray& siblings = task->parent() ? task->parent()->children() : mTopTasks;

    TaskArray::iterator taskIter = std::lower_bound(siblings.begin(), siblings.end(), task->index(), [] (const PTask& t, int index) { return t->index() < index;});
    if (taskIter != siblings.end())
        siblings.insert(taskIter, task);
    else
        siblings.append(task);

    mTaskModelIdMap[task->modelId()] = task;
    mTaskIdMap[task->id()] = task;
}

void Storage::removeTask(const PTask& task)
{
    auto taskModelIter = mTaskModelIdMap.find(task->modelId());
    if (taskModelIter != mTaskModelIdMap.end())
        mTaskModelIdMap.erase(taskModelIter);

    auto taskIter = mTaskIdMap.find(task->id());
    if (taskIter != mTaskIdMap.end())
        mTaskIdMap.erase(taskIter);
}

void Storage::loadTaskContent(Task& task)
{
    SQLite::Statement htmlQuery(Storage::instance().database(), "select html from task where id = :id");
    htmlQuery.bind(":id", (sqlite3_int64)task.mId);
    if (htmlQuery.executeStep())
    {
        task.mHtml = htmlQuery.getColumn(0).getText();
        task.mHtmlLoaded = true;
        task.mHtmlModified = false;
    }

    if (!task.mTimeLine)
    {
        task.mTimeLine = PTimeLine(new TimeLine());
        task.mTimeLine->setTaskId(task.mId);
        task.mTimeLine->load();
    }
}

void Storage::saveTask(const Task& task, SaveOptions options)
{
    const Task& t = task;

    if (!t.mTitleModified && !t.mHtmlModified && !t.mIndexModified && !t.mParentModified && options == Save_Automatic)
        return;

    const char* queryText = nullptr;
    // Minimize changes to DB
    if (t.mTitleModified && t.mHtmlModified)
        queryText = "update task set parentid = :parentid, flags = :flags, title = :title, html = :html, orderid = :orderid where id = :id";
    else
    if (t.mTitleModified)
        queryText = "update task set parentid = :parentid, flags = :flags, title = :title, orderid = :orderid where id = :id";
    else
    if (t.mHtmlModified)
        queryText = "update task set parentid = :parentid, flags = :flags, html = :html, orderid = :orderid where id = :id";
    else
        queryText = "update task set parentid = :parentid, flags = :flags, orderid = :orderid where id = :id";

    SQLite::Statement q(Storage::instance().database(), queryText);
    if (t.mParent)
        q.bind(":parentid", (sqlite3_int64)t.mParent->id());
    else
        q.bind(":parentid");

    q.bind(":flags", t.mFlags);

    if (t.mTitleModified)
        q.bind(":title", t.mTitle.toStdString());
    if (t.mHtmlModified)
        q.bind(":html", t.mHtml.toStdString());

    q.bind(":id", (sqlite3_int64)t.mId);
    q.bind(":orderid", t.mIndex);
    q.exec();
}

int Storage::findAttachmentCountOnTask(const Task &t)
{
    SQLite::Statement q(Storage::instance().database(), "select count(*) from file where (taskid = :taskid) and ((removed = 0) or (removed is null))");
    q.bind(":taskid", (sqlite3_int64)t.id());
    if (q.executeStep())
        return q.getColumn(0).getInt();
    else
        return 0;
}