app/src/main/java/de/dhbwloe/campusapp/database/DatabaseManager.java

   1 /* DatabaseManager.java
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  15  */
  16 package de.dhbwloe.campusapp.database;
  17 import android.app.Activity;
  18 import android.content.ContentValues;
  19 import android.database.Cursor;
  20 import android.database.sqlite.SQLiteDatabase;
  21
  22 import net.fortuna.ical4j.model.Component;
  23
  24 import java.util.ArrayList;
  25 import java.util.Date;
  26
  27 import de.dhbwloe.campusapp.CampusAppContext;
  28 import de.dhbwloe.campusapp.coursenames.CourseName;
  29 import de.dhbwloe.campusapp.mensaplan.MensaTagesplan;
  30 import de.dhbwloe.campusapp.news.NewsItem;
  31 import de.dhbwloe.campusapp.search.SearchIndices;
  32 import de.dhbwloe.campusapp.vorlesungen.CourseEvent;
  33 import de.dhbwloe.campusapp.vorlesungen.CourseGroup;
  34
  35 /**
  36  * Created by pk910 on 19.01.2016.
  37  */
  38 public class DatabaseManager {
  39     private static final String DATABASE_NAME = "DHBWLoe.CampusApp.db";
  40     private static final int DATABASE_VERSION = 3; // Datenbank Version - muss bei strukturellen Anpassungen erhöht werden
  41
  42     private CampusAppContext AppContext;
  43     private SQLiteDatabase database;
  44     private NewsDatabaseHelper newsDBHelper;
  45     private MensaplanDatabaseHelper mensaplanDBHelper;
  46     private VorlesungsplanDatabaseHelper vorlesungsplanDBHelper;
  47
  48
  49     public DatabaseManager(CampusAppContext context) {
  50         AppContext = context;
  51     }
  52
  53     private void openDatabase() {
  54         if(database != null)
  55             return;
  56
  57         database = AppContext.getMainActivity().openOrCreateDatabase(DATABASE_NAME, Activity.MODE_PRIVATE, null);
  58     }
  59
  60     public void initializeDatabase() {
  61         openDatabase();
  62         database.execSQL("CREATE TABLE IF NOT EXISTS Version(Version INT);");
  63
  64         // Abfragen der Datenbank Version
  65         Cursor resultSet = database.rawQuery("Select * from Version", null);
  66         int version;
  67         if(resultSet.moveToFirst()) {
  68             version = resultSet.getInt(0);
  69         } else {
  70             version = 0;
  71             database.execSQL("INSERT INTO Version (Version) VALUES (0);");
  72         }
  73
  74         resultSet.close();
  75         if(version < DATABASE_VERSION) // Upgrade der Datenbank Struktur (oder auch Initialisierung)
  76             upgradeTables(version, DATABASE_VERSION);
  77     }
  78
  79     private void upgradeTables(int oldVersion, int newVersion) {
  80         if(oldVersion == 0 && newVersion > 0) { // Initialisierung (noch keine Datenbank)
  81             database.execSQL("CREATE TABLE IF NOT EXISTS RuntimeCache " +
  82                     "(" +
  83                     "Reference TEXT, " +
  84                     "Value TEXT, " +
  85                     "LastUpdate INT, " +
  86                     "PRIMARY KEY (Reference)" +
  87                     ");");
  88             database.execSQL("CREATE TABLE IF NOT EXISTS SearchIndex " +
  89                     "(" +
  90                     "KeyName TEXT, " +
  91                     "SearchText TEXT, " +
  92                     "SearchTitle TEXT," +
  93                     "Description TEXT, " +
  94                     "StaticEntry INT, " +
  95                     "UpdateTime INT, " +
  96                     "TargetPage TEXT);");
  97
  98             // Vorlesungsplan
  99             database.execSQL("CREATE TABLE IF NOT EXISTS CourseCalendar " +
 100                     "(" +
 101                     "Id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " +
 102                     "CourseName TEXT, " +
 103                     "UniqueId TEXT, " +
 104                     "SequenceId INT, " +
 105                     "EventFrom INT, " +
 106                     "EventTo INT, " +
 107                     "EventTitle TEXT, " +
 108                     "EventLocation TEXT, " +
 109                     "EventStatus TEXT," +
 110                     "RecurRule TEXT," +
 111                     "ExcludeDates TEXT," +
 112                     "CourseGroupId INT," +
 113                     "UNIQUE (CourseName, UniqueId)" +
 114                     ");");
 115             database.execSQL("CREATE TABLE IF NOT EXISTS CourseCalendarEvent " +
 116                     "(" +
 117                     "EventId INT, " +
 118                     "EventFrom INT, " +
 119                     "EventTo INT, " +
 120                     "PRIMARY KEY (EventId, EventFrom, EventTo)" +
 121                     ");");
 122             database.execSQL("CREATE INDEX CourseCalendarEventIdx ON CourseCalendarEvent (EventFrom, EventTo);");
 123             database.execSQL("CREATE TABLE IF NOT EXISTS CourseCalendarGroup " +
 124                     "(" +
 125                     "GroupId INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " +
 126                     "CourseName INT," +
 127                     "GroupName TEXT, " +
 128                     "LastUpdate INT, " +
 129                     "UNIQUE (GroupName)" +
 130                     ");");
 131             database.execSQL("CREATE INDEX CourseCalendarGroupIdx ON CourseCalendarGroup (CourseName, GroupName);");
 132
 133             // Mensa Karten History is this actually used?)
 134             database.execSQL("CREATE TABLE IF NOT EXISTS NfcCardStore " +
 135                     "(" +
 136                     "CardId INT, " +
 137                     "UpdateTime INT," +
 138                     "CardBalance INT, " +
 139                     "CardLastTransaction INT, " +
 140                     "PRIMARY KEY (CardId, UpdateTime)" +
 141                     ");");
 142
 143             // Mensaplan
 144             database.execSQL("CREATE TABLE IF NOT EXISTS MensaPlan " +
 145                     "(" +
 146                     "PlanDate INT, " +
 147                     "MenuName TEXT, " +
 148                     "ChkSum INT, " +
 149                     "Name TEXT, " +
 150                     "NameHtml TEXT, " +
 151                     "Additional TEXT, " +
 152                     "Notes TEXT, " +
 153                     "PriceStudents INT, " +
 154                     "PriceEmployees INT, " +
 155                     "PriceGuests INT, " +
 156                     "PriceSchool INT, " +
 157                     "PRIMARY KEY (PlanDate, MenuName)" +
 158                     ");");
 159
 160             // News
 161             database.execSQL("CREATE TABLE IF NOT EXISTS News " +
 162                     "(" +
 163                     "Id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " +
 164                     "Source TEXT, " +
 165                     "Time INT, " +
 166                     "UniqueId TEXT, " +
 167                     "ChkSum INT, " +
 168                     "Title TEXT, " +
 169                     "Summary TEXT, " +
 170                     "Content TEXT, " +
 171                     "Link TEXT, " +
 172                     "Categories TEXT, " +
 173                     "UNIQUE(Source, UniqueId) " +
 174                     ");");
 175             database.execSQL("CREATE INDEX NewsIdx ON News (Source, Time);");
 176         }
 177         if(oldVersion < 2 && newVersion >= 2) {
 178             // Version 2
 179             database.execSQL("ALTER TABLE CourseCalendarEvent ADD EventType INT;");
 180         }
 181         if(oldVersion < 3 && newVersion >= 3) {
 182             // Version 3
 183             database.execSQL("CREATE TABLE IF NOT EXISTS CourseNames " +
 184                     "(" +
 185                     "CourseName TEXT, " +
 186                     "Status TEXT, " +
 187                     "LastUpdate INT" +
 188                     ");");
 189         }
 190         if(oldVersion < 4 && newVersion >= 4) {
 191             // Version 4
 192
 193         }
 194
 195         database.execSQL("UPDATE Version SET Version = " + Integer.toString(newVersion));
 196     }
 197
 198     public void addSearchIndices(SearchIndices[] indices) {
 199         // Hinzufügen oder Updaten mehrerer SearchIndice Objekte
 200         openDatabase();
 201         for(int i = 0; i < indices.length; i++) {
 202             String[] whereArgs = new String[] {
 203                     indices[i].getKeyName()
 204             };
 205             Cursor resultSet = database.rawQuery("SELECT UpdateTime FROM SearchIndex WHERE KeyName = ?", whereArgs);
 206             if(resultSet.moveToFirst()) {
 207                 long updateTime = resultSet.getLong(0);
 208                 if (updateTime < indices[i].getUpdateTime()) {
 209                     // remove
 210                     database.rawQuery("DELETE FROM SearchIndex WHERE KeyName = ?", whereArgs);
 211                 } else
 212                     continue;
 213             }
 214             resultSet.close();
 215             // add new
 216             try {
 217                 ContentValues indexValues = new ContentValues();
 218                 indexValues.put("KeyName", indices[i].getKeyName());
 219                 indexValues.put("SearchText", indices[i].getKeyWords());
 220                 indexValues.put("SearchTitle", indices[i].getTitle());
 221                 indexValues.put("Description", indices[i].getDescription());
 222                 indexValues.put("StaticEntry", indices[i].getIsStatic() ? 1 : 0);
 223                 indexValues.put("UpdateTime", indices[i].getUpdateTime());
 224                 indexValues.put("TargetPage", indices[i].getTarget());
 225
 226                 database.insertOrThrow("SearchIndex", null, indexValues);
 227             } catch(Exception e) {
 228                 e.printStackTrace();
 229             }
 230         }
 231     }
 232
 233     public SearchIndices[] performSearchRequest(String query, int maxResults) {
 234         // App Suche
 235         openDatabase();
 236         String[] whereArgs = new String[] {
 237                 "%" + query + "%"
 238         };
 239         Cursor resultSet = database.rawQuery("SELECT KeyName, SearchTitle, Description, StaticEntry, UpdateTime, TargetPage, SearchText FROM SearchIndex WHERE SearchText LIKE ? ORDER BY StaticEntry DESC, UpdateTime DESC", whereArgs);
 240         ArrayList<SearchIndices> indices = new ArrayList<SearchIndices>();
 241         if(resultSet.moveToFirst()) {
 242             int[] columnIndexes = {
 243                     resultSet.getColumnIndex("KeyName"),
 244                     resultSet.getColumnIndex("SearchTitle"),
 245                     resultSet.getColumnIndex("Description"),
 246                     resultSet.getColumnIndex("StaticEntry"),
 247                     resultSet.getColumnIndex("UpdateTime"),
 248                     resultSet.getColumnIndex("TargetPage"),
 249                     resultSet.getColumnIndex("SearchText")
 250             };
 251             do {
 252                 SearchIndices cIndices = new SearchIndices(resultSet.getString(columnIndexes[0]), (resultSet.getInt(columnIndexes[3]) == 1));
 253                 cIndices.setUpdateTime(resultSet.getLong(columnIndexes[4]));
 254                 cIndices.setTarget(resultSet.getString(columnIndexes[5]));
 255                 cIndices.addKeyWord(resultSet.getString(columnIndexes[6]));
 256                 cIndices.setTitle(resultSet.getString(columnIndexes[1]));
 257                 cIndices.setDescription(resultSet.getString(columnIndexes[2]));
 258                 indices.add(cIndices);
 259             } while (resultSet.moveToNext() && indices.size() < maxResults);
 260         }
 261         resultSet.close();
 262
 263         SearchIndices[] indicesArr = new SearchIndices[indices.size()];
 264         indicesArr = indices.toArray(indicesArr);
 265         return indicesArr;
 266     }
 267
 268     public void setRuntimeCache(String name, String value) {
 269         // Simple cache for runtime options
 270         openDatabase();
 271         long now = (new Date()).getTime() / 1000;
 272         String[] whereArgs = new String[] {
 273                 name
 274         };
 275         Cursor resultSet = database.rawQuery("SELECT Value FROM RuntimeCache WHERE Reference = ?", whereArgs);
 276         if(resultSet.moveToFirst()) {
 277             if(resultSet.getString(0).equalsIgnoreCase(value))
 278                 return;
 279             try {
 280                 ContentValues updateValues = new ContentValues();
 281                 updateValues.put("Value", value);
 282                 updateValues.put("LastUpdate", now);
 283
 284                 database.update("RuntimeCache", updateValues, "Reference = ?", whereArgs);
 285             } catch(Exception e) {
 286                 e.printStackTrace();
 287             }
 288         } else {
 289             try {
 290                 ContentValues indexValues = new ContentValues();
 291                 indexValues.put("Reference", name);
 292                 indexValues.put("Value", value);
 293                 indexValues.put("LastUpdate", now);
 294
 295                 database.insertOrThrow("RuntimeCache", null, indexValues);
 296             } catch(Exception e) {
 297                 e.printStackTrace();
 298             }
 299         }
 300         resultSet.close();
 301     }
 302
 303     public String getRuntimeCache(String name) {
 304         openDatabase();
 305         String value = null;
 306         String[] whereArgs = new String[] {
 307                 name
 308         };
 309         Cursor resultSet = database.rawQuery("SELECT Value FROM RuntimeCache WHERE Reference = ?", whereArgs);
 310         if(resultSet.moveToFirst()) {
 311             value = resultSet.getString(0);
 312         }
 313         resultSet.close();
 314         return value;
 315     }
 316
 317     public void addNfcCardData(NfcCardData nfcCardData) {
 318         openDatabase();
 319         String[] whereArgs = new String[] {
 320                 Integer.toString(nfcCardData.getUniqueId()),
 321                 Long.toString(nfcCardData.getLastUpdate())
 322         };
 323         Cursor resultSet = database.rawQuery("SELECT CardBalance FROM NfcCardStore WHERE CardId = ? AND UpdateTime = ?", whereArgs);
 324         if(resultSet.moveToFirst()) {
 325             try {
 326                 ContentValues updateValues = new ContentValues();
 327                 updateValues.put("CardBalance", nfcCardData.getBalance());
 328                 updateValues.put("CardLastTransaction", nfcCardData.getLastTransaction());
 329
 330                 database.update("NfcCardStore", updateValues, "CardId = ? AND UpdateTime = ?", whereArgs);
 331             } catch(Exception e) {
 332                 e.printStackTrace();
 333             }
 334         } else {
 335             try {
 336                 ContentValues indexValues = new ContentValues();
 337                 indexValues.put("CardId", nfcCardData.getUniqueId());
 338                 indexValues.put("UpdateTime", nfcCardData.getLastUpdate());
 339                 indexValues.put("CardBalance", nfcCardData.getBalance());
 340                 indexValues.put("CardLastTransaction", nfcCardData.getLastTransaction());
 341
 342                 database.insertOrThrow("NfcCardStore", null, indexValues);
 343             } catch(Exception e) {
 344                 e.printStackTrace();
 345             }
 346         }
 347         resultSet.close();
 348     }
 349
 350     public NfcCardData[] getNfcCardData(int lastLimit) {
 351         openDatabase();
 352         String value = null;
 353         Cursor resultSet;
 354         if(lastLimit > 0) {
 355             String[] whereArgs = {
 356                     Integer.toString(lastLimit)
 357             };
 358             resultSet = database.rawQuery("SELECT CardId,UpdateTime,CardBalance,CardLastTransaction FROM NfcCardStore ORDER BY UpdateTime DESC LIMIT ?", whereArgs);
 359         } else
 360             resultSet = database.rawQuery("SELECT CardId,UpdateTime,CardBalance,CardLastTransaction FROM NfcCardStore ORDER BY UpdateTime DESC", null);
 361         ArrayList<NfcCardData> nfcCardDatas = new ArrayList<NfcCardData>();
 362         if(resultSet.moveToFirst()) {
 363             do {
 364                 NfcCardData nfcCardData = new NfcCardData(resultSet.getInt(0), resultSet.getLong(1), resultSet.getInt(2), resultSet.getInt(3));
 365                 nfcCardDatas.add(nfcCardData);
 366             } while (resultSet.moveToNext());
 367         }
 368         resultSet.close();
 369         NfcCardData[] resultsArr = new NfcCardData[nfcCardDatas.size()];
 370         resultsArr = nfcCardDatas.toArray(resultsArr);
 371         return resultsArr;
 372     }
 373
 374     public NfcCardData getLatestNfcCardData(int cardId) {
 375         openDatabase();
 376         String value = null;
 377         String[] whereArgs = {
 378                 Integer.toString(cardId)
 379         };
 380         Cursor resultSet = database.rawQuery("SELECT CardId,UpdateTime,CardBalance,CardLastTransaction FROM NfcCardStore WHERE CardId = ? ORDER BY UpdateTime DESC LIMIT 1", whereArgs);
 381         NfcCardData nfcCardData = null;
 382         if(resultSet.moveToFirst()) {
 383             nfcCardData = new NfcCardData(resultSet.getInt(0), resultSet.getLong(1), resultSet.getInt(2), resultSet.getInt(3));
 384         }
 385         resultSet.close();
 386         return nfcCardData;
 387     }
 388
 389     public CourseName[] getCourseNames() {
 390         openDatabase();
 391         String value = null;
 392         Cursor resultSet;
 393         resultSet = database.rawQuery("SELECT CourseName, Status, LastUpdate FROM CourseNames ORDER BY CourseName ASC", null);
 394
 395         ArrayList<CourseName> courseNames = new ArrayList<CourseName>();
 396         if(resultSet.moveToFirst()) {
 397             do {
 398                 CourseName cname = new CourseName(resultSet.getString(0), resultSet.getString(1), resultSet.getLong(2));
 399                 courseNames.add(cname);
 400             } while (resultSet.moveToNext());
 401         }
 402         resultSet.close();
 403         CourseName[] resultsArr = new CourseName[courseNames.size()];
 404         resultsArr = courseNames.toArray(resultsArr);
 405         return resultsArr;
 406     }
 407
 408     public CourseName getLatestCourseName() {
 409         openDatabase();
 410         CourseName lastCourse = null;
 411         Cursor resultSet;
 412         resultSet = database.rawQuery("SELECT CourseName, Status, LastUpdate FROM CourseNames ORDER BY LastUpdate DESC LIMIT 1", null);
 413
 414         if(resultSet.moveToFirst()) {
 415             lastCourse = new CourseName(resultSet.getString(0), resultSet.getString(1), resultSet.getLong(2));
 416         }
 417         resultSet.close();
 418         return lastCourse;
 419     }
 420
 421     public void addCourseName(CourseName courseName) {
 422         openDatabase();
 423         String[] whereArgs = new String[] {
 424                 courseName.getName()
 425         };
 426         Cursor resultSet = database.rawQuery("SELECT CourseName FROM CourseNames WHERE CourseName = ?", whereArgs);
 427         if(resultSet.moveToFirst()) {
 428             if(courseName.isActiveCourse()) {
 429                 try {
 430                     ContentValues updateValues = new ContentValues();
 431                     updateValues.put("Status", courseName.getStatus());
 432                     updateValues.put("LastUpdate", courseName.getLastUpdate());
 433
 434                     database.update("CourseNames", updateValues, "CourseName = ?", whereArgs);
 435                 } catch (Exception e) {
 436                     e.printStackTrace();
 437                 }
 438             } else {
 439                 database.delete("CourseNames", "CourseName = ?", whereArgs);
 440             }
 441         } else if(courseName.isActiveCourse()) {
 442             try {
 443                 ContentValues indexValues = new ContentValues();
 444                 indexValues.put("CourseName", courseName.getName());
 445                 indexValues.put("Status", courseName.getStatus());
 446                 indexValues.put("LastUpdate", courseName.getLastUpdate());
 447
 448                 database.insertOrThrow("CourseNames", null, indexValues);
 449             } catch(Exception e) {
 450                 e.printStackTrace();
 451             }
 452         }
 453         resultSet.close();
 454     }
 455
 456     public boolean haveCourseName(String courseName) {
 457         openDatabase();
 458         String[] whereArgs = new String[] {
 459                 courseName
 460         };
 461         Cursor resultSet = database.rawQuery("SELECT CourseName FROM CourseNames WHERE CourseName = ?", whereArgs);
 462         boolean result;
 463         if(resultSet.moveToFirst()) {
 464             result = true;
 465         } else {
 466             result = false;
 467         }
 468         return result;
 469     }
 470
 471     public void updateCourseCalendar(CourseEvent event, Component cevent) {
 472         openDatabase();
 473         if(vorlesungsplanDBHelper == null)
 474             vorlesungsplanDBHelper = new VorlesungsplanDatabaseHelper(AppContext, database);
 475         vorlesungsplanDBHelper.updateCourseCalendar(event, cevent);
 476     }
 477
 478     public CourseEvent[] getCourseCalendarEvents(String coursename, long timeFrom, long timeTo) {
 479         openDatabase();
 480         if(vorlesungsplanDBHelper == null)
 481             vorlesungsplanDBHelper = new VorlesungsplanDatabaseHelper(AppContext, database);
 482         return vorlesungsplanDBHelper.getCourseCalendarEvents(coursename, timeFrom, timeTo);
 483     }
 484
 485     public CourseEvent[] getCourseEventsByGroup(CourseGroup group) {
 486         openDatabase();
 487         if(vorlesungsplanDBHelper == null)
 488             vorlesungsplanDBHelper = new VorlesungsplanDatabaseHelper(AppContext, database);
 489         return vorlesungsplanDBHelper.getCourseEventsByGroup(group);
 490     }
 491
 492     public CourseEvent[] getCourseCalendarTimetable(String coursename, long timeFrom, int days) {
 493         openDatabase();
 494         if(vorlesungsplanDBHelper == null)
 495             vorlesungsplanDBHelper = new VorlesungsplanDatabaseHelper(AppContext, database);
 496         return vorlesungsplanDBHelper.getCourseCalendarTimetable(coursename, timeFrom, days);
 497     }
 498
 499     public CourseGroup getCourseGroup(int courseGroupId) {
 500         openDatabase();
 501         if(vorlesungsplanDBHelper == null)
 502             vorlesungsplanDBHelper = new VorlesungsplanDatabaseHelper(AppContext, database);
 503         return vorlesungsplanDBHelper.getCourseGroup(courseGroupId);
 504     }
 505
 506     public CourseGroup getCourseGroup(String coursename, String groupname) {
 507         openDatabase();
 508         if(vorlesungsplanDBHelper == null)
 509             vorlesungsplanDBHelper = new VorlesungsplanDatabaseHelper(AppContext, database);
 510         return vorlesungsplanDBHelper.getCourseGroup(coursename, groupname);
 511     }
 512
 513     public CourseGroup addCourseGroup(String coursename, String groupname) {
 514         openDatabase();
 515         if(vorlesungsplanDBHelper == null)
 516             vorlesungsplanDBHelper = new VorlesungsplanDatabaseHelper(AppContext, database);
 517         return vorlesungsplanDBHelper.addCourseGroup(coursename, groupname);
 518     }
 519
 520     public CourseGroup[] getCourseGroups(String coursename, Date notBefore) {
 521         openDatabase();
 522         if(vorlesungsplanDBHelper == null)
 523             vorlesungsplanDBHelper = new VorlesungsplanDatabaseHelper(AppContext, database);
 524         return vorlesungsplanDBHelper.getCourseGroups(coursename, notBefore);
 525     }
 526
 527     public CourseEvent[] getCourseExamEvents(String coursename, long timeFrom, long timeTo) {
 528         openDatabase();
 529         if(vorlesungsplanDBHelper == null)
 530             vorlesungsplanDBHelper = new VorlesungsplanDatabaseHelper(AppContext, database);
 531         return vorlesungsplanDBHelper.getCourseExamEvents(coursename, timeFrom, timeTo);
 532     }
 533
 534     public void updateMensaTagesplan(MensaTagesplan plan) {
 535         openDatabase();
 536         if(mensaplanDBHelper == null)
 537             mensaplanDBHelper = new MensaplanDatabaseHelper(AppContext, database);
 538         mensaplanDBHelper.updateMensaTagesplan(plan);
 539     }
 540
 541     public MensaTagesplan[] getMensaTagesplan(long timeFrom, long timeTo) {
 542         openDatabase();
 543         if(mensaplanDBHelper == null)
 544             mensaplanDBHelper = new MensaplanDatabaseHelper(AppContext, database);
 545         return mensaplanDBHelper.getMensaTagesplan(timeFrom, timeTo);
 546     }
 547
 548     public long[] getDaysWithPlanData(long timeFrom, long timeTo) {
 549         openDatabase();
 550         if(mensaplanDBHelper == null)
 551             mensaplanDBHelper = new MensaplanDatabaseHelper(AppContext, database);
 552         return mensaplanDBHelper.getDaysWithPlanData(timeFrom, timeTo);
 553     }
 554
 555     public long[] getWeeksWithPlanData(long timeFrom, long timeTo) {
 556         openDatabase();
 557         if(mensaplanDBHelper == null)
 558             mensaplanDBHelper = new MensaplanDatabaseHelper(AppContext, database);
 559         return mensaplanDBHelper.getWeeksWithPlanData(timeFrom, timeTo);
 560     }
 561
 562     public void updateNewsItem(NewsItem news) {
 563         openDatabase();
 564         if(newsDBHelper == null)
 565             newsDBHelper = new NewsDatabaseHelper(AppContext, database);
 566         newsDBHelper.updateNewsItem(news);
 567     }
 568
 569     public NewsItem[] getNewsItems(String source, long timeFrom, long timeTo) {
 570         openDatabase();
 571         if(newsDBHelper == null)
 572             newsDBHelper = new NewsDatabaseHelper(AppContext, database);
 573         return newsDBHelper.getNewsItems(source, timeFrom, timeTo);
 574     }
 575
 576 }