mediagoblin/db/models.py

   1 # GNU MediaGoblin -- federated, autonomous media hosting
   2 # Copyright (C) 2011 Free Software Foundation, Inc
   3 #
   4 # This program is free software: you can redistribute it and/or modify
   5 # it under the terms of the GNU Affero General Public License as published by
   6 # the Free Software Foundation, either version 3 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU Affero General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Affero General Public License
  15 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 import datetime, uuid
  18
  19 from mongokit import Document, Set
  20
  21 from mediagoblin import util
  22 from mediagoblin.auth import lib as auth_lib
  23 from mediagoblin import mg_globals
  24 from mediagoblin.db import migrations
  25 from mediagoblin.db.util import ASCENDING, DESCENDING, ObjectId
  26 from mediagoblin.util import Pagination
  27
  28 ###################
  29 # Custom validators
  30 ###################
  31
  32 ########
  33 # Models
  34 ########
  35
  36
  37 class User(Document):
  38     __collection__ = 'users'
  39
  40     structure = {
  41         'username': unicode,
  42         'email': unicode,
  43         'created': datetime.datetime,
  44         'plugin_data': dict, # plugins can dump stuff here.
  45         'pw_hash': unicode,
  46         'email_verified': bool,
  47         'status': unicode,
  48         'verification_key': unicode,
  49         'is_admin': bool,
  50         'url' : unicode,
  51         'bio' : unicode
  52         }
  53
  54     required_fields = ['username', 'created', 'pw_hash', 'email']
  55
  56     default_values = {
  57         'created': datetime.datetime.utcnow,
  58         'email_verified': False,
  59         'status': u'needs_email_verification',
  60         'verification_key': lambda: unicode(uuid.uuid4()),
  61         'is_admin': False}
  62
  63     migration_handler = migrations.UserMigration
  64
  65     def check_login(self, password):
  66         """
  67         See if a user can login with this password
  68         """
  69         return auth_lib.bcrypt_check_password(
  70             password, self['pw_hash'])
  71
  72
  73 class MediaEntry(Document):
  74     __collection__ = 'media_entries'
  75
  76     structure = {
  77         'uploader': ObjectId,
  78         'title': unicode,
  79         'slug': unicode,
  80         'created': datetime.datetime,
  81         'description': unicode, # May contain markdown/up
  82         'description_html': unicode, # May contain plaintext, or HTML
  83         'media_type': unicode,
  84         'media_data': dict, # extra data relevant to this media_type
  85         'plugin_data': dict, # plugins can dump stuff here.
  86         'tags': [unicode],
  87         'state': unicode,
  88
  89         # For now let's assume there can only be one main file queued
  90         # at a time
  91         'queued_media_file': [unicode],
  92
  93         # A dictionary of logical names to filepaths
  94         'media_files': dict,
  95
  96         # The following should be lists of lists, in appropriate file
  97         # record form
  98         'attachment_files': list,
  99
 100         # This one should just be a single file record
 101         'thumbnail_file': [unicode]}
 102
 103     required_fields = [
 104         'uploader', 'created', 'media_type', 'slug']
 105
 106     default_values = {
 107         'created': datetime.datetime.utcnow,
 108         'state': u'unprocessed'}
 109
 110     migration_handler = migrations.MediaEntryMigration
 111
 112     def main_mediafile(self):
 113         pass
 114
 115     def get_comments(self, page):
 116         cursor = self.db.MediaComment.find({
 117                 'media_entry': self['_id']}).sort('created', DESCENDING)
 118
 119         pagination = Pagination(page, cursor)
 120         comments = pagination()
 121
 122         data = list()
 123         for comment in comments:
 124             comment['author'] = self.db.User.find_one({
 125                     '_id': comment['author']})
 126             data.append(comment)
 127
 128         return (data, pagination)
 129
 130     def generate_slug(self):
 131         self['slug'] = util.slugify(self['title'])
 132
 133         duplicate = mg_globals.database.media_entries.find_one(
 134             {'slug': self['slug']})
 135
 136         if duplicate:
 137             self['slug'] = "%s-%s" % (self['_id'], self['slug'])
 138
 139     def url_for_self(self, urlgen):
 140         """
 141         Generate an appropriate url for ourselves
 142
 143         Use a slug if we have one, else use our '_id'.
 144         """
 145         uploader = self.uploader()
 146
 147         if self.get('slug'):
 148             return urlgen(
 149                 'mediagoblin.user_pages.media_home',
 150                 user=uploader['username'],
 151                 media=self['slug'])
 152         else:
 153             return urlgen(
 154                 'mediagoblin.user_pages.media_home',
 155                 user=uploader['username'],
 156                 media=unicode(self['_id']))
 157
 158     def url_to_prev(self, urlgen):
 159         """
 160         Provide a url to the previous entry from this user, if there is one
 161         """
 162         cursor = self.db.MediaEntry.find({'_id' : {"$lt": self['_id']},
 163                                           'uploader': self['uploader']}).sort(
 164                                                     '_id', DESCENDING).limit(1)
 165
 166         if cursor.count():
 167             return urlgen('mediagoblin.user_pages.media_home',
 168                           user=self.uploader()['username'],
 169                           media=unicode(cursor[0]['_id']))
 170
 171     def url_to_next(self, urlgen):
 172         """
 173         Provide a url to the next entry from this user, if there is one
 174         """
 175         cursor = self.db.MediaEntry.find({'_id' : {"$gt": self['_id']},
 176                                           'uploader': self['uploader']}).sort(
 177                                                     '_id', ASCENDING).limit(1)
 178
 179         if cursor.count():
 180             return urlgen('mediagoblin.user_pages.media_home',
 181                           user=self.uploader()['username'],
 182                           media=unicode(cursor[0]['_id']))
 183
 184     def uploader(self):
 185         return self.db.User.find_one({'_id': self['uploader']})
 186
 187 class MediaComment(Document):
 188     __collection__ = 'media_comments'
 189
 190     structure = {
 191         'media_entry': ObjectId,
 192         'author': ObjectId,
 193         'created': datetime.datetime,
 194         'content': unicode,
 195         'content_html': unicode}
 196
 197     required_fields = [
 198         'media_entry', 'author', 'created', 'content']
 199
 200     default_values = {
 201         'created': datetime.datetime.utcnow}
 202
 203     def media_entry(self):
 204         return self.db.MediaEntry.find_one({'_id': self['media_entry']})
 205
 206     def author(self):
 207         return self.db.User.find_one({'_id': self['author']})
 208
 209 REGISTER_MODELS = [
 210     MediaEntry,
 211     User,
 212     MediaComment]
 213
 214
 215 def register_models(connection):
 216     """
 217     Register all models in REGISTER_MODELS with this connection.
 218     """
 219     connection.register(REGISTER_MODELS)
 220