lib/mark.php

   1 <?php
   2         require_once 'persistance.php';
   3
   4         class Mark implements sql, persistance
   5         {
   6                 static $db;
   7
   8                 var $id;
   9                 var $creationDate;
  10                 var $pageUrl;
  11                 var $text;
  12                 var $startNodePath, $startOffset;
  13                 var $endNodePath, $endOffset;
  14                 var $owner;
  15
  16                 function __construct($id = NULL)
  17                 {
  18                         $this->creationDate = time();
  19                         if ($id) {
  20                                 $this->id = $id;
  21                         }
  22                 }
  23
  24                 static function get_table_name()
  25                 {
  26                         return "marks";
  27                 }
  28
  29                 static function sql_select($wildcards = NULL)
  30                 {
  31                         $tableName = self::get_table_name();
  32
  33                         $order = ' order by creationDate desc, pageUrl ';
  34                         if (array_key_exists('order', $wildcards)) {
  35                                 $order = " order by ". $wildcards['order'];
  36                                 unset($wildcards['order']);
  37                         }
  38
  39                         $limit = '';
  40                         if (array_key_exists('limit', $wildcards)) {
  41                                 $limit = " limit ". $wildcards['limit'];
  42                                 unset($wildcards['limit']);
  43                         }
  44
  45                         if (empty($wildcards)) {
  46                                 return "SELECT id, creationDate, pageUrl, text, owner, startNodePath, startOffset, endNodePath, endOffset from $tableName $order $limit;";
  47                         }
  48
  49                         $tuples = array();
  50                         if (array_key_exists('pageUrl', $wildcards)) {
  51                                 $tuples []= " pageUrl LIKE '". $wildcards['pageUrl'] ."%'";
  52                                 unset($wildcards['pageUrl']);
  53                         }
  54
  55                         foreach ($wildcards as $key => $value) {
  56                                 $tuples []= "$key='$value'";
  57                         }
  58
  59                         $conditions = implode(' and ', $tuples);
  60
  61                         $query = "SELECT id, creationDate, pageUrl, text, owner, startNodePath, startOffset, endNodePath, endOffset from $tableName where $conditions $order $limit;";
  62
  63                         return $query;
  64                 }
  65
  66                 function toHTMLanchor()
  67                 {
  68                         $anchor = "<a href='". $this->pageUrl ."' >". $this->text ."</a>";
  69                         return $anchor;
  70                 }
  71
  72                 function toSQLinsert()
  73                 {
  74                         $id            = $this->id;
  75                         $creationDate  = date('c', $this->creationDate);
  76                         $pageUrl       = $this->pageUrl;
  77                         $text          = $this->text;
  78                         $owner         = $this->owner;
  79                         $startNodePath = $this->startNodePath;
  80                         $startOffset   = $this->startOffset;
  81                         $endNodePath   = $this->endNodePath;
  82                         $endOffset     = $this->endOffset;
  83
  84                         $tableName = Mark::get_table_name();
  85                         return "INSERT into $tableName (id, creationDate, pageUrl, text, owner, startNodePath, startOffset, endNodePath, endOffset) values ('$id', '$creationDate', '$pageUrl', '$text', '$owner', '$startNodePath', '$startOffset', '$endNodePath', '$endOffset');";
  86                 }
  87
  88                 function toSQLselect()
  89                 {
  90                         return "SELECT creationDate, pageUrl, text, owner, startNodePath, startOffset, endNodePath, endOffset from marks where id='". $this->id ."';";
  91                 }
  92
  93                 static function set_db($db, $user = "", $password = "")
  94                 {
  95                         if ($db instanceof PDO) {
  96                                 self::$db =& $db;
  97                         } else {
  98                                 if (empty($user)) {
  99                                         self::$db =& new PDO($db);
 100                                 } else {
 101                                         self::$db =& new PDO($db, $user, $password);
 102                                 }
 103                         }
 104
 105                         return self::$db;
 106                 }
 107
 108                 static function count($wildcards = NULL, $db = NULL)
 109                 {
 110                         if ($db == NULL) {
 111                                 $db = self::$db;
 112                         }
 113                         if (! $db instanceof PDO) {
 114                                 throw new Exception("Not a Data Base");
 115                         }
 116
 117                         $tableName = Mark::get_table_name();
 118                         $query = "select count(*) from $tableName";
 119                         if ($result = $db->query($query)) {
 120                                 $result = $result->fetchAll();
 121                         } else {
 122                                 echo "Query error";
 123                                 print_r($db->errorInfo());
 124                                 throw new Exception("Query error");
 125                         }
 126
 127                         return $result[0][0];
 128                 }
 129
 130                 static function select($wildcards = NULL, $db = NULL)
 131                 {
 132                         if ($db == NULL) {
 133                                 $db = self::$db;
 134                         }
 135                         if (! $db instanceof PDO) {
 136                                 throw new Exception("Not a Data Base");
 137                         }
 138                         $marks = array();
 139                         $query = self::sql_select($wildcards);
 140                         if ($result = $db->query($query)) {
 141                                 $result = $result->fetchAll();
 142                         } else {
 143                                 echo "Query error";
 144                                 print_r($db->errorInfo());
 145                                 throw new Exception("Query error");
 146                         }
 147                         foreach ($result as $r) {
 148                                 $mark = new Mark($r['id']);
 149                                 $mark->creationDate = strtotime($r['creationDate']);
 150                                 $mark->pageUrl = strip_http_get_params($r['pageUrl']);
 151                                 $mark->text = $r['text'];
 152                                 $mark->owner = $r['owner'];
 153                                 $mark->startNodePath = json_decode($r['startNodePath']);
 154                                 $mark->startOffset = $r['startOffset'];
 155                                 $mark->endNodePath = json_decode($r['endNodePath']);
 156                                 $mark->endOffset = $r['endOffset'];
 157                                 array_push( $marks, $mark);
 158                         }
 159
 160                         return $marks;
 161                 }
 162
 163                 function save($db = NULL)
 164                 {
 165                         if ($db == NULL) {
 166                                 $db = self::$db;
 167                         }
 168                         $query = $this->toSQLinsert();
 169
 170                         $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 171                         $statement = $db->query($query);
 172
 173                         return $statement;
 174                 }
 175
 176                 function load($db = NULL)
 177                 {
 178                         if ($db == NULL) {
 179                                 $db = self::$db;
 180                         }
 181                         if (is_string($db)) {
 182                                 $db = new PDO($db, $user, $pass);
 183                         }
 184                         $query  = $this->toSQLselect();
 185                         if ($result = $db->query($query)) {
 186                                 $result = $result->fetch();
 187                         } else {
 188                                 throw new Exception("Query error");
 189                         }
 190
 191                         $this->creationDate = strtotime($result['creationDate']);
 192                         $this->pageUrl = $result['pageUrl'];
 193                         $this->text = $result['text'];
 194                         $this->owner = $result['owner'];
 195                         $this->startNodePath = $result['startNodePath'];
 196                         $this->startOffset = $result['startOffset'];
 197                         $this->endNodePath = $result['endNodePath'];
 198                         $this->endOffset = $result['endOffset'];
 199
 200                         return $this;
 201                 }
 202
 203                 function __toString()
 204                 {
 205                         return json_encode($this);
 206                 }
 207         }
 208
 209 function strip_http_get_params($url)
 210 {
 211         if (!$urlBaseLength = strpos($url, '?')) return $url;
 212         return substr($url, 0, $urlBaseLength);
 213 }