f3a904de996c9a303efe6cefe94ceb7cc623df03
[grauphel.git] / lib / notestorage.php
1 <?php
2 /**
3  * Part of grauphel
4  *
5  * PHP version 5
6  *
7  * @category  Tools
8  * @package   Grauphel
9  * @author    Christian Weiske <cweiske@cweiske.de>
10  * @copyright 2014 Christian Weiske
11  * @license   http://www.gnu.org/licenses/agpl.html GNU AGPL v3
12  * @link      http://cweiske.de/grauphel.htm
13  */
14 namespace OCA\Grauphel\Lib;
15
16 /**
17  * Flat file storage for notes
18  *
19  * @category  Tools
20  * @package   Grauphel
21  * @author    Christian Weiske <cweiske@cweiske.de>
22  * @copyright 2014 Christian Weiske
23  * @license   http://www.gnu.org/licenses/agpl.html GNU AGPL v3
24  * @version   Release: @package_version@
25  * @link      http://cweiske.de/grauphel.htm
26  */
27 class NoteStorage
28 {
29     protected $urlGen;
30     protected $username;
31
32     public function __construct($urlGen)
33     {
34         $this->urlGen   = $urlGen;
35     }
36
37     public function setUsername($username)
38     {
39         $this->username = $username;
40     }
41
42     /**
43      * Create a new sync data object for fresh users.
44      * Used by loadSyncData()
45      *
46      * @return SyncData New synchronization statistics
47      */
48     protected function getNewSyncData()
49     {
50         $syncdata = new SyncData();
51         $syncdata->initNew($this->username);
52         return $syncdata;
53     }
54
55     public function getTags()
56     {
57     }
58
59     /**
60      * Updates the given $note object with data from $noteUpdate.
61      * Sets the last-sync-revision to $syncRevision
62      *
63      * @param object  $note         Original note object
64      * @param object  $noteUpdate   Update note object from a PUT to the API
65      * @param integer $syncRevision Current sync revision number
66      *
67      * @return void
68      */
69     public function update($note, $noteUpdate, $syncRevision)
70     {
71         static $updateFields = array(
72             'create-date',
73             'last-change-date',
74             'last-metadata-change-date',
75             'note-content',
76             'note-content-version',
77             'open-on-startup',
78             'pinned',
79             'tags',
80             'title',
81         );
82
83         $changed = array();
84         foreach ($updateFields as $field) {
85             $changed[$field] = false;
86             if (isset($noteUpdate->$field)) {
87                 if ($note->$field != $noteUpdate->$field) {
88                     $note->$field = $noteUpdate->$field;
89                     $changed[$field] = true;
90                 }
91             }
92         }
93
94         if (!isset($noteUpdate->{'last-change-date'})
95             && ($changed['title'] || $changed['note-content'])
96         ) {
97             //no idea how to get the microseconds in there
98             $note->{'last-change-date'} = date('c');
99         }
100
101         if (!isset($noteUpdate->{'last-metadata-change-date'})) {
102             //no idea how to get the microseconds in there
103             $note->{'last-metadata-change-date'} = date('c');
104         }
105
106         if (isset($noteUpdate->{'node-content'})
107             && $note->{'note-content-version'} == 0
108         ) {
109             $note->{'note-content-version'} = 0.3;
110         }
111
112         $note->{'last-sync-revision'} = $syncRevision;
113     }
114
115     /**
116      * Loads synchronization data for the given user.
117      * Creates fresh sync data if there are none for the user.
118      *
119      * @return SyncData Synchronization statistics (revision, sync guid)
120      */
121     public function loadSyncData()
122     {
123         $row = \OC_DB::executeAudited(
124             'SELECT * FROM `*PREFIX*grauphel_syncdata`'
125             . ' WHERE `syncdata_user` = ?',
126             array($this->username)
127         )->fetchRow();
128
129         if ($row === false) {
130             $syncdata = $this->getNewSyncData($this->username);
131             $this->saveSyncData($this->username, $syncdata);
132         } else {
133             $syncdata = new SyncData();
134             $syncdata->latestSyncRevision = (int) $row['syncdata_latest_sync_revision'];
135             $syncdata->currentSyncGuid    = $row['syncdata_current_sync_guid'];
136         }
137
138         return $syncdata;
139     }
140
141     /**
142      * Save synchronization data for the given user.
143      *
144      * @param SyncData $syncdata Synchronization data object
145      *
146      * @return void
147      */
148     public function saveSyncData(SyncData $syncdata)
149     {
150         $row = \OC_DB::executeAudited(
151             'SELECT * FROM `*PREFIX*grauphel_syncdata`'
152             . ' WHERE `syncdata_user` = ?',
153             array($this->username)
154         )->fetchRow();
155
156         if ($row === false) {
157             //INSERT
158             $sql = 'INSERT INTO `*PREFIX*grauphel_syncdata`'
159                 . '(`syncdata_user`, `syncdata_latest_sync_revision`, `syncdata_current_sync_guid`)'
160                 . ' VALUES(?, ?, ?)';
161             $params = array(
162                 $this->username,
163                 $syncdata->latestSyncRevision,
164                 $syncdata->currentSyncGuid
165             );
166         } else {
167             //UPDATE
168             $data = array(
169                 'syncdata_latest_sync_revision' => $syncdata->latestSyncRevision,
170                 'syncdata_current_sync_guid'    => $syncdata->currentSyncGuid,
171             );
172             $sql = 'UPDATE `*PREFIX*grauphel_syncdata` SET'
173                 . ' `' . implode('` = ?, `', array_keys($data)) . '` = ?'
174                 . ' WHERE `syncdata_user` = ?';
175             $params = array_values($data);
176             $params[] = $this->username;
177         }
178         \OC_DB::executeAudited($sql, $params);
179     }
180
181     /**
182      * Load a note from the storage.
183      *
184      * @param string  $guid      Note identifier
185      * @param boolean $createNew Create a new note if it does not exist
186      *
187      * @return object Note object, NULL if !$createNew and note does not exist
188      */
189     public function load($guid, $createNew = true)
190     {
191         $row = \OC_DB::executeAudited(
192             'SELECT * FROM `*PREFIX*grauphel_notes`'
193             . ' WHERE `note_user` = ? AND `note_guid` = ?',
194             array($this->username, $guid)
195         )->fetchRow();
196
197         if ($row === false) {
198             if (!$createNew) {
199                 return null;
200             }
201             return (object) array(
202                 'guid' => $guid,
203
204                 'create-date'               => null,
205                 'last-change-date'          => null,
206                 'last-metadata-change-date' => null,
207
208                 'title'                => null,
209                 'note-content'         => null,
210                 'note-content-version' => 0.3,
211
212                 'open-on-startup' => false,
213                 'pinned'          => false,
214                 'tags'            => array(),
215             );
216         }
217         
218         return $this->noteFromRow($row);
219     }
220
221     /**
222      * Save a note into storage.
223      *
224      * @param object $note Note to save
225      *
226      * @return void
227      */
228     public function save($note)
229     {
230         $row = \OC_DB::executeAudited(
231             'SELECT * FROM `*PREFIX*grauphel_notes`'
232             . ' WHERE `note_user` = ? AND `note_guid` = ?',
233             array($this->username, $note->guid)
234         )->fetchRow();
235
236         $data = $this->rowFromNote($note);
237         if ($row === false) {
238             //INSERT
239             $data['note_user'] = $this->username;
240             $sql = 'INSERT INTO `*PREFIX*grauphel_notes`'
241                 . ' (`' . implode('`, `', array_keys($data)) . '`)'
242                 . ' VALUES(' . implode(', ', array_fill(0, count($data), '?')) . ')';
243             $params = array_values($data);
244         } else {
245             //UPDATE
246             $sql = 'UPDATE `*PREFIX*grauphel_notes` SET '
247                 . '`' . implode('` = ?, `', array_keys($data)) . '` = ?'
248                 . ' WHERE `note_user` = ? AND `note_guid` = ?';
249             $params = array_values($data);
250             $params[] = $this->username;
251             $params[] = $note->guid;
252         }
253         \OC_DB::executeAudited($sql, $params);
254     }
255
256     /**
257      * Delete a note from storage.
258      *
259      * @param object $guid ID of the note
260      *
261      * @return void
262      */
263     public function delete($guid)
264     {
265         \OC_DB::executeAudited(
266             'DELETE FROM `*PREFIX*grauphel_notes`'
267             . ' WHERE `note_user` = ? AND `note_guid` = ?',
268             array($this->username, $guid)
269         );
270     }
271
272     /**
273      * Load notes for the given user in short form.
274      * Optionally only those changed after $since revision
275      *
276      * @param integer $since Revision number after which the notes changed
277      *
278      * @return array Array of short note objects
279      */
280     public function loadNotesOverview($since = null)
281     {
282         $result = \OC_DB::executeAudited(
283             'SELECT `note_guid`, `note_title`, `note_last_sync_revision`'
284             . ' FROM `*PREFIX*grauphel_notes`'
285             . ' WHERE note_user = ?',
286             array($this->username)
287         );
288
289         $notes = array();
290         while ($row = $result->fetchRow()) {
291             if ($since !== null && $row['note_last_sync_revision'] <= $since) {
292                 continue;
293             }
294             $notes[] = array(
295                 'guid' => $row['note_guid'],
296                 'ref'  => array(
297                     'api-ref' => $this->urlGen->getAbsoluteURL(
298                         $this->urlGen->linkToRoute(
299                             'grauphel.api.note',
300                             array(
301                                 'username' => $this->username,
302                                 'guid' => $row['note_guid']
303                             )
304                         )
305                     ),
306                     'href' => null,//FIXME
307                 ),
308                 'title' => $row['note_title'],
309             );
310         }
311
312         return $notes;
313     }
314
315     /**
316      * Load notes for the given user in full form.
317      * Optionally only those changed after $since revision
318      *
319      * @param integer $since Revision number after which the notes changed
320      *
321      * @return array Array of full note objects
322      */
323     public function loadNotesFull($since = null)
324     {
325         $result = \OC_DB::executeAudited(
326             'SELECT * FROM `*PREFIX*grauphel_notes`'
327             . ' WHERE note_user = ?',
328             array($this->username)
329         );
330
331         $notes = array();
332         while ($row = $result->fetchRow()) {
333             if ($since !== null && $row['note_last_sync_revision'] <= $since) {
334                 continue;
335             }
336             $notes[] = $this->noteFromRow($row);
337         }
338
339         return $notes;
340     }
341
342     protected function noteFromRow($row)
343     {
344         return (object) array(
345             'guid'  => $row['note_guid'],
346
347             'create-date'               => $row['note_create_date'],
348             'last-change-date'          => $row['note_last_change_date'],
349             'last-metadata-change-date' => $row['note_last_metadata_change_date'],
350
351             'title'                => $row['note_title'],
352             'note-content'         => $row['note_content'],
353             'note-content-version' => $row['note_content_version'],
354
355             'open-on-startup' => (bool) $row['note_open_on_startup'],
356             'pinned'          => (bool) $row['note_pinned'],
357             'tags'            => json_decode($row['note_tags']),
358
359             'last-sync-revision' => (int) $row['note_last_sync_revision'],
360         );
361     }
362
363     protected function rowFromNote($note)
364     {
365         return array(
366             'note_guid'  => $note->guid,
367             'note_title' => $note->title,
368
369             'note_content'         => $note->{'note-content'},
370             'note_content_version' => $note->{'note-content-version'},
371
372             'note_create_date'               => $note->{'create-date'},
373             'note_last_change_date'          => $note->{'last-change-date'},
374             'note_last_metadata_change_date' => $note->{'last-metadata-change-date'},
375             
376             'note_open_on_startup' => $note->{'open-on-startup'},
377             'note_pinned'          => $note->pinned,
378             'note_tags'            => json_encode($note->tags),
379
380             'note_last_sync_revision' => $note->{'last-sync-revision'},
381         );
382     }
383 }
384 ?>