Creating EventModel class

diff --git a/src/app/app.pro b/src/app/app.pro
index 258c0a6f6954ab977a4ff26dc8796cd90a2390b9..48d12f67f1a2d8fd3c2d46e8204f91da86c34757 100644 (file)
--- a/src/app/app.pro
+++ b/src/app/app.pro
@@ -1,6 +1,7 @@
 TEMPLATE = app
 TARGET = fosdem
 DESTDIR = ../bin
+QT += sql
 
 # module dependencies
 LIBS += -L$$DESTDIR -lgui -lmodel

diff --git a/src/gui/gui.pro b/src/gui/gui.pro
index 0ee18844475e98c9adf24a9b36c71df75b7d1041..f8f6988df18764d0051f6d6e216ca7acf524ab4a 100644 (file)
--- a/src/gui/gui.pro
+++ b/src/gui/gui.pro
@@ -2,12 +2,13 @@ TEMPLATE = lib
 TARGET = gui
 DESTDIR = ../bin
 CONFIG += static
+QT += sql
 
 # module dependencies
-LIBS += -L$$DESTDIR -lmodel
-INCLUDEPATH += ../model
-DEPENDPATH += . ../model
-TARGETDEPS += $$DESTDIR/libmodel.a
+LIBS += -L$$DESTDIR -lmodel -orm
+INCLUDEPATH += ../orm ../model
+DEPENDPATH += . ../orm ../model
+TARGETDEPS += $$DESTDIR/liborm.a $$DESTDIR/libmodel.a
 
 
 # A shamelessly long list of sources, headers and forms.

diff --git a/src/gui/mainwindow.cpp b/src/gui/mainwindow.cpp
index d1e4fe6d584d04b0e951ca1c2eb1ea9c5e96723d..e0f20d49847b5b2c56d6bd3558f32250b582dc03 100644 (file)
--- a/src/gui/mainwindow.cpp
+++ b/src/gui/mainwindow.cpp
@@ -1,6 +1,19 @@
 #include "mainwindow.h"
 
+#include <QTreeView>
+
+#include <eventmodel.h>
+
 MainWindow::MainWindow(QWidget *parent)
     : QMainWindow(parent)
 {
+    // open database connection
+    QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
+    db.setDatabaseName("fosdem-test.sqlite");
+    db.open();
+
+    QTreeView * view = new QTreeView(parent);
+    this->setCentralWidget(view);
+
+    view->setModel(new EventModel());
 }

diff --git a/src/model/event.cpp b/src/model/event.cpp
index ff7f1d2fc17622701b0ccedab11b9299df83e1d4..ffc805ad803302cb9d454b6be829dba647fbaad2 100644 (file)
--- a/src/model/event.cpp
+++ b/src/model/event.cpp
@@ -13,11 +13,20 @@ QString const Event::sTableName = QString("event");
 
 Event Event::getById(int id, int conferenceId)
 {
-    QString query = selectQuery() + "WHERE id = :id AND xid_conference = :conf";
+    QSqlQuery query;
+    query.prepare(selectQuery() + "WHERE id = :id AND xid_conference = :conf");
+    query.bindValue(":id", id);
+    query.bindValue(":conf", conferenceId);
+    return loadOne(query);
+}
+
+QList<Event> Event::getByDate(const QDate& date, int conferenceId)
+{
+    QSqlQuery query;
+    query.prepare(selectQuery() + "WHERE xid_conference = :conf AND start >= :start AND start < :end ORDER BY start");
+    query.bindValue(":conf", conferenceId);
+    query.bindValue(":start", convertToDb(date, QVariant::DateTime));
+    query.bindValue(":end", convertToDb(date.addDays(1), QVariant::DateTime));
 
-    QSqlQuery q;
-    q.prepare(query);
-    q.bindValue(":id", id);
-    q.bindValue(":conf", conferenceId);
-    return loadOne(q);
+    return load(query);
 }

diff --git a/src/model/event.h b/src/model/event.h
index b3efb48688a176ba2cdef726c2e1e8ea9e1fd3d5..05c74a87b85e37cac1f24d4211a11dd9d613637a 100644 (file)
--- a/src/model/event.h
+++ b/src/model/event.h
@@ -23,6 +23,7 @@ public:
 
 public:
     static Event getById(int id, int conferenceId);
+    static QList<Event> getByDate(const QDate& date, int conferenceId);
 
 public:
     int id() const { return value("id").toInt(); }

diff --git a/src/model/eventmodel.cpp b/src/model/eventmodel.cpp
new file mode 100644 (file)
index 0000000..768791b
--- /dev/null
+++ b/src/model/eventmodel.cpp
@@ -0,0 +1,118 @@
+#include "eventmodel.h"
+
+EventModel::EventModel() :
+        mEvents(Event::getByDate(QDate(2009, 2, 7), 1))
+{
+    createTimeGroups();
+}
+
+void EventModel::createTimeGroups()
+{
+    mGroups.clear();
+    mParents.clear();
+
+    if (mEvents.empty())
+    {
+        return;
+    }
+
+    const int timeSpan = 5400;
+
+    QTime startTime = mEvents.first().start().time();
+    mGroups << EventModel::Group(QString("%1 - %2").arg(startTime.toString("HH:mm"),
+        startTime.addSecs(timeSpan).toString("HH:mm")), 0);
+    QTime nextGroupTime = mEvents.first().start().time().addSecs(timeSpan);
+
+    for (int i=0; i<mEvents.count(); i++)
+    {
+        QTime eventTime = mEvents.at(i).start().time();
+
+        if (nextGroupTime < eventTime)
+        {
+            mGroups.last().mChildCount = i - mGroups.last().mFirstEventIndex;
+            mGroups << EventModel::Group(QString("%1 - %2").arg(nextGroupTime.toString("HH:mm"),
+                nextGroupTime.addSecs(timeSpan).toString("HH:mm")), i);
+            nextGroupTime = nextGroupTime.addSecs(timeSpan);
+        }
+
+        // add parent-child relation
+        mParents[mEvents.at(i).id()] = mGroups.count() - 1;
+    }
+
+    mGroups.last().mChildCount = mEvents.count() - mGroups.last().mFirstEventIndex;
+}
+
+QVariant EventModel::data(const QModelIndex& index, int role) const
+{
+    if (index.isValid() && role == Qt::DisplayRole)
+    {
+        if (index.internalId() == 0)
+        {
+            return mGroups.at(index.row()).mTitle;
+        }
+        else
+        {
+            return static_cast<Event*>(index.internalPointer())->id();
+        }
+    }
+
+    return QVariant();
+}
+
+QModelIndex EventModel::index(int row, int column, const QModelIndex& parent) const
+{
+    // TODO: add checks for out of range rows
+
+    if (!parent.isValid())
+    {
+        return createIndex(row, column, 0);
+    }
+    else if (parent.internalId() == 0)
+    {
+        const Group& group = mGroups.at(parent.row());
+        Event* event = const_cast<Event*>(&mEvents.at(row + group.mFirstEventIndex));
+        return createIndex(row, column, reinterpret_cast<void*>(event));
+    }
+    else
+    {
+        return QModelIndex();
+    }
+}
+
+QModelIndex EventModel::parent(const QModelIndex & index) const
+{
+    if (index.isValid())
+    {
+        if (index.internalId() == 0)
+        {
+            return QModelIndex();
+        }
+
+        Event * event = static_cast<Event*>(index.internalPointer());
+
+        return createIndex(mParents[event->id()], 0, 0);
+    }
+
+    return QModelIndex();
+}
+
+int EventModel::columnCount(const QModelIndex & parent) const
+{
+    Q_UNUSED(parent);
+    return 1;
+}
+
+int EventModel::rowCount (const QModelIndex & parent) const
+{
+    if (!parent.isValid())
+    {
+        return mGroups.count();
+    }
+
+    if (parent.internalId() == 0)
+    {
+        return mGroups.at(parent.row()).mChildCount;
+    }
+
+    return 0;
+}

diff --git a/src/model/eventmodel.h b/src/model/eventmodel.h
new file mode 100644 (file)
index 0000000..9c06db2
--- /dev/null
+++ b/src/model/eventmodel.h
@@ -0,0 +1,43 @@
+#ifndef EVENTMODEL_H
+#define EVENTMODEL_H
+
+#include <QAbstractItemModel>
+
+#include "event.h"
+
+class EventModel : public QAbstractItemModel
+{
+public:
+    EventModel();
+    QVariant data(const QModelIndex& index, int role) const;
+    QModelIndex index(int row, int column, const QModelIndex & parent = QModelIndex()) const;
+    QModelIndex parent ( const QModelIndex & index ) const;
+    int columnCount ( const QModelIndex & parent = QModelIndex() ) const;
+    int rowCount ( const QModelIndex & parent = QModelIndex() ) const;
+
+private:
+    struct Group
+    {
+        Group(const QString & title,
+              int firstEventIndex) :
+
+            mTitle(title),
+            mFirstEventIndex(firstEventIndex),
+            mChildCount(0)
+        {}
+
+        QString mTitle;
+        int mFirstEventIndex;
+        int mChildCount;
+    };
+
+private:
+    void createTimeGroups();
+
+private:
+    QList<Event> mEvents;
+    QList<Group> mGroups;
+    QHash<int, int> mParents;
+};
+
+#endif // EVENTMODEL_H

diff --git a/src/model/model.pro b/src/model/model.pro
index 726488f0381f3edb98a4ede41ec2a03af97e3662..c8e0b625f740f302d6b7cfbc39e960c8a1e35871 100644 (file)
--- a/src/model/model.pro
+++ b/src/model/model.pro
@@ -10,6 +10,10 @@ INCLUDEPATH += ../orm
 DEPENDPATH += . ../orm
 TARGETDEPS += $$DESTDIR/liborm.a
 
-HEADERS += event.h
-SOURCES += event.cpp
+HEADERS += \
+    event.h \
+    eventmodel.h
+SOURCES += \
+    event.cpp \
+    eventmodel.cpp
 

diff --git a/src/orm/ormrecord.h b/src/orm/ormrecord.h
index a939248a0dc2b74d058d6eabeb3b7c8947b0db9a..5502b79de8b12b9f79d41e895240ca02b1519467 100644 (file)
--- a/src/orm/ormrecord.h
+++ b/src/orm/ormrecord.h
@@ -162,7 +162,7 @@ QVariant OrmRecord<T>::convertToC(QVariant value, QVariant::Type colType)
 template <typename T>
 QVariant OrmRecord<T>::convertToDb(QVariant value, QVariant::Type colType)
 {
-    if (colType == QVariant::DateTime && value.type() == QVariant::DateTime)
+    if (colType == QVariant::DateTime && value.canConvert<QDateTime>())
     {
         return value.toDateTime().toTime_t();
     }

diff --git a/src/test/model/eventtest.cpp b/src/test/model/eventtest.cpp
index 515ab42295803e7fcc64ec3ec9d72acf4057e70d..232421a2b1d357385765c0d59d429d0d9390d7ca 100644 (file)
--- a/src/test/model/eventtest.cpp
+++ b/src/test/model/eventtest.cpp
@@ -28,6 +28,12 @@ void EventTest::getById()
     QCOMPARE(event.language(), QString("English"));
 }
 
+void EventTest::getByDate()
+{
+    QCOMPARE(Event::getByDate(QDate(2009, 2, 7), 1).count(), 127);
+    QCOMPARE(Event::getByDate(QDate(2009, 2, 8), 1).count(), 154);
+}
+
 void EventTest::storingValues()
 {
     Event event;

diff --git a/src/test/model/eventtest.h b/src/test/model/eventtest.h
index 9a734a85c9d9e75ce696cbb92e054f4dc52988ee..920191e9ca26439a0e7c096d856d657f5c3480fc 100644 (file)
--- a/src/test/model/eventtest.h
+++ b/src/test/model/eventtest.h
@@ -11,6 +11,7 @@ private slots:
     void initTestCase();
 
     void getById();
+    void getByDate();
     void storingValues();
     void hydrate();
     void columnsForSelect();