webapp/backend/planet.py

   1 #!/usr/bin/python
   2
   3 import datetime
   4 import re
   5 import textile
   6 import unicodedata
   7
   8 from misc import Object
   9
  10 class PlanetEntry(Object):
  11         def __init__(self, backend, data):
  12                 Object.__init__(self, backend)
  13
  14                 self.data = data
  15
  16         @property
  17         def id(self):
  18                 return self.data.id
  19
  20         @property
  21         def slug(self):
  22                 return self.data.slug
  23
  24         def set_title(self, title):
  25                 if self.title == title:
  26                         return
  27
  28                 self.db.execute("UPDATE planet SET title = %s WHERE id = %s", title, self.id)
  29                 self.data["title"] = title
  30
  31         title = property(lambda s: s.data.title, set_title)
  32
  33         @property
  34         def url(self):
  35                 return "http://planet.ipfire.org/post/%s" % self.slug
  36
  37         def set_published(self, published):
  38                 if self.published == published:
  39                         return
  40
  41                 self.db.execute("UPDATE planet SET published = %s WHERE id = %s",
  42                         published, self.id)
  43                 self.data["published"] = published
  44
  45         published = property(lambda s: s.data.published, set_published)
  46
  47         @property
  48         def year(self):
  49                 return self.published.year
  50
  51         @property
  52         def month(self):
  53                 return self.published.month
  54
  55         @property
  56         def updated(self):
  57                 return self.data.updated
  58
  59         def get_markdown(self):
  60                 return self.data.markdown
  61
  62         def set_markdown(self, markdown):
  63                 if self.markdown == markdown:
  64                         return
  65
  66                 markup = self.render(markdown)
  67                 self.db.execute("UPDATE planet SET markdown = %s, markup = %s WHERE id = %s",
  68                         markdown, markup, self.id)
  69
  70                 self.data.update({
  71                         "markdown" : markdown,
  72                         "markup"   : markup,
  73                 })
  74
  75         markdown = property(get_markdown, set_markdown)
  76
  77         @property
  78         def markup(self):
  79                 if self.data.markup:
  80                         return self.data.markup
  81
  82                 return self.render(self.markdown)
  83
  84         @property
  85         def abstract(self):
  86                 return self.render(self.markdown, 400)
  87
  88         def render(self, text, limit=0):
  89                 return self.planet.render(text, limit)
  90
  91         @property
  92         def text(self):
  93                 # Compat for markup
  94                 return self.markup
  95
  96         @property
  97         def author(self):
  98                 if not hasattr(self, "_author"):
  99                         self._author = self.accounts.get_by_uid(self.data.author_id)
 100
 101                 return self._author
 102
 103         def set_status(self, status):
 104                 if self.status == status:
 105                         return
 106
 107                 self.db.execute("UPDATE planet SET status = %s WHERE id = %s", status, self.id)
 108                 self.data["status"] = status
 109
 110         status = property(lambda s: s.data.status, set_status)
 111
 112         def is_draft(self):
 113                 return self.status == "draft"
 114
 115         def is_published(self):
 116                 return self.status == "published"
 117
 118         def count_view(self, referer=None, location=None):
 119                 self.db.execute("INSERT INTO planet_views(post_id, referer, location) \
 120                         VALUES(%s, %s, %s)", self.id, referer, location)
 121
 122                 if hasattr(self, "_views"):
 123                         self._views += 1
 124
 125         @property
 126         def views(self):
 127                 if not hasattr(self, "_views"):
 128                         res = self.db.get("SELECT COUNT(*) AS views FROM planet_views \
 129                                 WHERE post_id = %s", self.id)
 130
 131                         self._views = res.views
 132
 133                 return self._views
 134
 135
 136 class Planet(Object):
 137         def get_authors(self):
 138                 query = self.db.query("SELECT DISTINCT author_id FROM planet WHERE status = %s \
 139                         AND published IS NOT NULL AND published <= NOW()", "published")
 140
 141                 authors = []
 142                 for author in query:
 143                         author = self.accounts.search(author.author_id)
 144                         if author:
 145                                 authors.append(author)
 146
 147                 return sorted(authors)
 148
 149         def get_years(self):
 150                 res = self.db.query("SELECT DISTINCT EXTRACT(YEAR FROM published)::integer AS year \
 151                         FROM planet WHERE status = %s ORDER BY year DESC", "published")
 152
 153                 return [row.year for row in res]
 154
 155         def get_entry_by_slug(self, slug):
 156                 entry = self.db.get("SELECT * FROM planet WHERE slug = %s", slug)
 157
 158                 if entry:
 159                         return PlanetEntry(self.backend, entry)
 160
 161         def get_entry_by_id(self, id):
 162                 entry = self.db.get("SELECT * FROM planet WHERE id = %s", id)
 163
 164                 if entry:
 165                         return PlanetEntry(self.backend, entry)
 166
 167         def get_entries(self, limit=3, offset=None, status="published", author_id=None):
 168                 query = "SELECT * FROM planet"
 169                 args, clauses = [], []
 170
 171                 if status:
 172                         clauses.append("status = %s")
 173                         args.append(status)
 174
 175                         if status == "published":
 176                                 clauses.append("published <= NOW()")
 177
 178                 if author_id:
 179                         clauses.append("author_id = %s")
 180                         args.append(author_id)
 181
 182                 if clauses:
 183                         query += " WHERE %s" % " AND ".join(clauses)
 184
 185                 query += " ORDER BY published DESC"
 186
 187                 # Respect limit and offset
 188                 if limit:
 189                         query += " LIMIT %s"
 190                         args.append(limit)
 191
 192                         if offset:
 193                                 query += " OFFSET %s"
 194                                 args.append(offset)
 195
 196                 entries = []
 197                 for entry in self.db.query(query, *args):
 198                         entry = PlanetEntry(self.backend, entry)
 199                         entries.append(entry)
 200
 201                 return entries
 202
 203         def get_entries_by_author(self, author_id, limit=None, offset=None):
 204                 return self.get_entries(limit=limit, offset=offset, author_id=author_id)
 205
 206         def get_entries_by_year(self, year):
 207                 entries = self.db.query("SELECT * FROM planet \
 208                         WHERE status = %s AND EXTRACT(YEAR FROM published) = %s \
 209                         ORDER BY published DESC", "published", year)
 210
 211                 return [PlanetEntry(self.backend, e) for e in entries]
 212
 213         def get_hot_entries(self, days=30, limit=8):
 214                 entries = self.db.query("WITH hottest AS (SELECT post_id, COUNT(post_id) AS count \
 215                         FROM planet_views WHERE \"when\" >= NOW() - INTERVAL '%s days' \
 216                         GROUP BY post_id ORDER BY count DESC) SELECT * FROM planet \
 217                         LEFT JOIN hottest ON planet.id = hottest.post_id \
 218                         WHERE hottest.count IS NOT NULL \
 219                         ORDER BY hottest.count DESC LIMIT %s",
 220                         days, limit)
 221
 222                 return [PlanetEntry(self.backend, e) for e in entries]
 223
 224         def render(self, text, limit=0):
 225                 if limit and len(text) >= limit:
 226                         text = text[:limit] + "..."
 227
 228                 return textile.textile(text)
 229
 230         def _generate_slug(self, title):
 231                 slug = unicodedata.normalize("NFKD", title).encode("ascii", "ignore")
 232                 slug = re.sub(r"[^\w]+", " ", slug)
 233                 slug = "-".join(slug.lower().strip().split())
 234
 235                 if not slug:
 236                         slug = "entry"
 237
 238                 while True:
 239                         e = self.db.get("SELECT * FROM planet WHERE slug = %s", slug)
 240                         if not e:
 241                                 break
 242                         slug += "-"
 243
 244                 return slug
 245
 246         def create(self, title, markdown, author, status="published", published=None):
 247                 slug = self._generate_slug(title)
 248                 markup = self.render(markdown)
 249
 250                 if published is None:
 251                         published = datetime.datetime.utcnow()
 252
 253                 id = self.db.execute("INSERT INTO planet(author_id, slug, title, status, \
 254                         markdown, markup, published) VALUES(%s, %s, %s, %s, %s, %s, %s) RETURNING id",
 255                         author.uid, slug, title, status, markdown, markup, published)
 256
 257                 if id:
 258                         return self.get_entry_by_id(id)
 259
 260         def update_entry(self, entry):
 261                 self.db.execute("UPDATE planet SET title = %s, markdown = %s WHERE id = %s",
 262                         entry.title, entry.markdown, entry.id)
 263
 264         def save_entry(self, entry):
 265                 slug = self._generate_slug(entry.title)
 266
 267                 id = self.db.execute("INSERT INTO planet(author_id, title, slug, markdown, published) \
 268                         VALUES(%s, %s, %s, %s, NOW())", entry.author.uid, entry.title, slug, entry.markdown)
 269
 270                 return id
 271
 272         def search(self, what):
 273                 res = self.db.query("WITH \
 274                         q      AS (SELECT plainto_tsquery(%s, %s) AS query), \
 275                         ranked AS (SELECT id, query, ts_rank_cd(to_tsvector(%s, markdown), query) AS rank \
 276                                 FROM planet, q WHERE markdown @@ query ORDER BY rank DESC) \
 277                         SELECT *, ts_headline(markup, ranked.query, 'MinWords=100, MaxWords=110') AS markup FROM planet \
 278                                 JOIN ranked ON planet.id = ranked.id \
 279                                 WHERE status = %s AND published IS NOT NULL AND published <= NOW() \
 280                                 ORDER BY ranked DESC LIMIT 10",
 281                         "english", what, "english", "published")
 282
 283                 return [PlanetEntry(self.backend, e) for e in res]