# object.
#######################################################
- setup_globals(app = self)
+ setup_globals(app=self)
# Workbench *currently* only used by celery, so this only
# matters in always eager mode :)
self.middleware = [util.import_component(m)(self)
for m in middleware.ENABLED_MIDDLEWARE]
-
def __call__(self, environ, start_response):
request = Request(environ)
'Username or email',
[wtforms.validators.Required()])
- def validate_username(form,field):
- if not (re.match(r'^\w+$',field.data) or
- re.match(r'^.+@[^.].*\.[a-z]{2,10}$',field.data, re.IGNORECASE)):
+ def validate_username(form, field):
+ if not (re.match(r'^\w+$', field.data) or
+ re.match(r'^.+@[^.].*\.[a-z]{2,10}$', field.data,
+ re.IGNORECASE)):
raise wtforms.ValidationError(u'Incorrect input')
token = wtforms.HiddenField(
'',
[wtforms.validators.Required()])
-
u"http://{host}{uri}?"
u"userid={userid}&token={verification_key}")
+
def send_verification_email(user, request):
"""
Send the verification email to users to activate their accounts.
u"http://{host}{uri}?"
u"userid={userid}&token={fp_verification_key}")
+
def send_fp_verification_email(user, request):
"""
Send the verification email to users to change their password.
[user['email']],
'GNU MediaGoblin - Change forgotten password!',
rendered_email)
-
controller='mediagoblin.views:simple_template_render'),
Route('mediagoblin.auth.forgot_password', '/forgot_password/',
controller='mediagoblin.auth.views:forgot_password'),
- Route('mediagoblin.auth.verify_forgot_password', '/forgot_password/verify/',
+ Route('mediagoblin.auth.verify_forgot_password',
+ '/forgot_password/verify/',
controller='mediagoblin.auth.views:verify_forgot_password'),
Route('mediagoblin.auth.fp_changed_success',
'/forgot_password/changed_success/',
request, 'mediagoblin.user_pages.user_home',
user=user['username'])
-
- # do not reveal whether or not there is a matching user, just move along
+ # do not reveal whether or not there is a matching user
return redirect(request, 'mediagoblin.auth.fp_email_sent')
return render_to_response(
pymongo. Read beow for why, but note that nobody is actually doing
this and there's no proof that we'll ever support more than
MongoDB... it would be a huge amount of work to do so.
-
+
If you really want to prove that possible, jump on IRC and talk to
us about making such a branch. In the meanwhile, it doesn't hurt to
have things as they are... if it ever makes it hard for us to
('created', DESCENDING)]},
'state_uploader_tags_created': {
- # Indexing on processed?, media uploader, associated tags, and timestamp
- # Used for showing media items matching a tag search, most recent first.
+ # Indexing on processed?, media uploader, associated tags, and
+ # timestamp Used for showing media items matching a tag
+ # search, most recent first.
'index': [('state', ASCENDING),
('uploader', ASCENDING),
('tags.slug', DESCENDING),
{'fail_error': {'$exists': False}},
{'$set': {'fail_error': None}},
multi=True)
-
+
collection.update(
{'fail_metadata': {'$exists': False}},
{'$set': {'fail_metadata': {}}},
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-import datetime, uuid
+import datetime
+import uuid
from mongokit import Document
'username': unicode,
'email': unicode,
'created': datetime.datetime,
- 'plugin_data': dict, # plugins can dump stuff here.
+ 'plugin_data': dict, # plugins can dump stuff here.
'pw_hash': unicode,
'email_verified': bool,
'status': unicode,
'verification_key': unicode,
'is_admin': bool,
- 'url' : unicode,
- 'bio' : unicode, # May contain markdown
- 'bio_html': unicode, # May contain plaintext, or HTML
- 'fp_verification_key': unicode, # forgotten password verification key
- 'fp_token_expire': datetime.datetime
+ 'url': unicode,
+ 'bio': unicode, # May contain markdown
+ 'bio_html': unicode, # May contain plaintext, or HTML
+ 'fp_verification_key': unicode, # forgotten password verification key
+ 'fp_token_expire': datetime.datetime,
}
required_fields = ['username', 'created', 'pw_hash', 'email']
critical to this piece of media but may be usefully relevant to people
viewing the work. (currently unused.)
- - fail_error: path to the exception raised
- - fail_metadata:
+ - fail_error: path to the exception raised
+ - fail_metadata:
"""
__collection__ = 'media_entries'
'title': unicode,
'slug': unicode,
'created': datetime.datetime,
- 'description': unicode, # May contain markdown/up
- 'description_html': unicode, # May contain plaintext, or HTML
+ 'description': unicode, # May contain markdown/up
+ 'description_html': unicode, # May contain plaintext, or HTML
'media_type': unicode,
- 'media_data': dict, # extra data relevant to this media_type
- 'plugin_data': dict, # plugins can dump stuff here.
+ 'media_data': dict, # extra data relevant to this media_type
+ 'plugin_data': dict, # plugins can dump stuff here.
'tags': [dict],
'state': unicode,
return self.db.MediaComment.find({
'media_entry': self['_id']}).sort('created', DESCENDING)
- def get_display_media(self, media_map, fetch_order=DISPLAY_IMAGE_FETCHING_ORDER):
+ def get_display_media(self, media_map,
+ fetch_order=DISPLAY_IMAGE_FETCHING_ORDER):
"""
Find the best media for display.
"""
Provide a url to the previous entry from this user, if there is one
"""
- cursor = self.db.MediaEntry.find({'_id' : {"$gt": self['_id']},
+ cursor = self.db.MediaEntry.find({'_id': {"$gt": self['_id']},
'uploader': self['uploader'],
'state': 'processed'}).sort(
'_id', ASCENDING).limit(1)
"""
Provide a url to the next entry from this user, if there is one
"""
- cursor = self.db.MediaEntry.find({'_id' : {"$lt": self['_id']},
+ cursor = self.db.MediaEntry.find({'_id': {"$lt": self['_id']},
'uploader': self['uploader'],
'state': 'processed'}).sort(
'_id', DESCENDING).limit(1)
Register all models in REGISTER_MODELS with this connection.
"""
connection.register(REGISTER_MODELS)
-
port = app_config.get('db_port')
if port:
port = asint(port)
-
+
if use_pymongo:
connection = pymongo.Connection(
app_config.get('db_host'), port)
#################
# The default migration registry...
-#
+#
# Don't set this yourself! RegisterMigration will automatically fill
# this with stuff via decorating methods in migrations.py
-class MissingCurrentMigration(Exception): pass
+class MissingCurrentMigration(Exception):
+ pass
MIGRATIONS = {}
return _make_safe(wrapper, controller)
+
def get_media_entry_by_id(controller):
"""
Pass in a MediaEntry based off of a url component
return controller(request, media=media, *args, **kwargs)
return _make_safe(wrapper, controller)
-
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-
-
name=request.POST['attachment_name'] \
or request.POST['attachment_file'].filename,
filepath=attachment_public_filepath,
- created=datetime.utcnow()
+ created=datetime.utcnow(),
))
media.save()
'setup': 'mediagoblin.gmg_commands.migrate:migrate_parser_setup',
'func': 'mediagoblin.gmg_commands.migrate:migrate',
'help': 'Apply all unapplied bulk migrations to the database'},
- 'adduser':{
+ 'adduser': {
'setup': 'mediagoblin.gmg_commands.users:adduser_parser_setup',
'func': 'mediagoblin.gmg_commands.users:adduser',
'help': 'Creates an user'},
if __name__ == '__main__':
main_cli()
-
args.mongorestore_path,
'-d', db.name,
os.path.join(args._cache_path['database'], db.name)])
-
+
p.wait()
_log.info('...Database imported')
'''
if args.cache_path:
if os.path.exists(args.cache_path):
- _log.error('The cache directory must not exist before you run this script')
+ _log.error('The cache directory must not exist '
+ 'before you run this script')
_log.error('Cache directory: {0}'.format(args.cache_path))
return False
globa_config, app_config = setup_global_and_app_config(args.conf_file)
setup_storage()
-
+
connection, db = setup_connection_and_db_from_config(
app_config, use_pymongo=True)
for collection, index_name in removed_indexes:
print "Removed index '%s' in collection '%s'" % (
index_name, collection)
-
+
# Migrate
print "\n== Applying migrations... =="
migration_manager.migrate_new(
pre_callback=_print_started_migration,
post_callback=_print_finished_migration)
-
+
# Add new indexes
print "\n== Adding new indexes... =="
new_indexes = db_util.add_new_indexes(db)
db = mg_globals.database
users_with_username = \
db.User.find({
- 'username': args.username.lower()
+ 'username': args.username.lower(),
}).count()
if users_with_username:
db = mg_globals.database
- user = db.User.one({'username':unicode(args.username.lower())})
+ user = db.User.one({'username': unicode(args.username.lower())})
if user:
user['is_admin'] = True
user.save()
db = mg_globals.database
- user = db.User.one({'username':unicode(args.username.lower())})
+ user = db.User.one({'username': unicode(args.username.lower())})
if user:
user['pw_hash'] = auth_lib.bcrypt_gen_password_hash(args.password)
user.save()
print 'Password successfully changed'
else:
print 'The user doesn\'t exist'
-
from mediagoblin.storage import storage_system_from_config
-class Error(Exception): pass
-class ImproperlyConfigured(Error): pass
+class Error(Exception):
+ pass
+
+
+class ImproperlyConfigured(Error):
+ pass
def setup_global_and_app_config(config_path):
"in fact they appear to be from the future?!")
setup_globals(
- db_connection = connection,
- database = db)
+ db_connection=connection,
+ database=db)
return connection, db
queue_store = storage_system_from_config(global_config[key_long])
setup_globals(
- public_store = public_store,
- queue_store = queue_store)
+ public_store=public_store,
+ queue_store=queue_store)
return public_store, queue_store
workbench_manager = WorkbenchManager(app_config['workbench_path'])
- setup_globals(workbench_manager = workbench_manager)
+ setup_globals(workbench_manager=workbench_manager)
def setup_beaker_cache():
for key, value in celery_settings.iteritems():
setattr(this_module, key, value)
-
+
if set_environ:
os.environ['CELERY_CONFIG_MODULE'] = settings_module
if not os.path.exists(mgoblin_conf_file):
raise IOError(
"MEDIAGOBLIN_CONFIG not set or file does not exist")
-
+
# By setting the environment variable here we should ensure that
# this is the module that gets set up.
os.environ['CELERY_CONFIG_MODULE'] = module_name
# For now the validator just works with the default functions,
# but in the future if we want to add additional validation/configuration
# functions we'd add them to validator.functions here.
- #
+ #
# See also:
# http://www.voidspace.org.uk/python/validate.html#adding-functions
validator = Validator()
Route('mediagoblin.listings.tag_atom_feed', "/{tag}/atom/",
controller="mediagoblin.listings.views:tag_atom_feed"),
]
-
{u'state': u'processed',
u'tags.slug': tag_slug})
cursor = cursor.sort('created', DESCENDING)
-
+
pagination = Pagination(page, cursor)
media_entries = pagination()
ATOM_DEFAULT_NR_OF_UPDATED_ITEMS = 15
+
def tag_atom_feed(request):
"""
generates the atom feed with the tag images
WARNING = 'warning'
ERROR = 'error'
+
def add_message(request, level, text):
messages = request.session.setdefault('messages', [])
messages.append({'level': level, 'text': text})
request.session.save()
+
def fetch_messages(request, clear_from_session=True):
messages = request.session.get('messages')
if messages and clear_from_session:
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
class NoOpMiddleware(object):
def __init__(self, mg_app):
"""
If the processing failed we should mark that in the database.
- Assuming that the exception raised is a subclass of BaseProcessingFail,
- we can use that to get more information about the failure and store that
- for conveying information to users about the failure, etc.
+ Assuming that the exception raised is a subclass of
+ BaseProcessingFail, we can use that to get more information
+ about the failure and store that for conveying information to
+ users about the failure, etc.
"""
entry_id = args[0]
mark_entry_failed(entry_id, exc)
"""
Mark a media entry as having failed in its conversion.
- Uses the exception that was raised to mark more information. If the
- exception is a derivative of BaseProcessingFail then we can store extra
- information that can be useful for users telling them why their media failed
- to process.
+ Uses the exception that was raised to mark more information. If
+ the exception is a derivative of BaseProcessingFail then we can
+ store extra information that can be useful for users telling them
+ why their media failed to process.
Args:
- entry_id: The id of the media entry
with queued_file:
original_filepath = create_pub_filepath(entry, queued_filepath[-1])
- with mgg.public_store.get_file(original_filepath, 'wb') as original_file:
+ with mgg.public_store.get_file(original_filepath, 'wb') \
+ as original_file:
original_file.write(queued_file.read())
mgg.queue_store.delete_file(queued_filepath)
from mediagoblin.util import lazy_pass_to_ugettext as _
+
class BaseProcessingFail(Exception):
"""
Base exception that all other processing failure messages should
subclass from.
-
+
You shouldn't call this itself; instead you should subclass it
and provid the exception_path and general_message applicable to
this error.
"""
general_message = u''
-
+
@property
def exception_path(self):
return u"%s:%s" % (
def __init__(self, **metadata):
self.metadata = metadata or {}
-
-
+
+
class BadMediaFail(BaseProcessingFail):
"""
Error that should be raised when an inappropriate file was given
import cloudfiles
import mimetypes
+
class CloudFilesStorage(StorageInterface):
'''
OpenStack/Rackspace Cloud's Swift/CloudFiles support
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-
-
from mimetypes import guess_type
-
ALLOWED = ['image/jpeg', 'image/png', 'image/tiff', 'image/gif']
+
def check_filetype(posted_file):
if not guess_type(posted_file.filename)[0] in ALLOWED:
return False
entry['description'] = unicode(request.POST.get('description'))
entry['description_html'] = cleaned_markdown_conversion(
entry['description'])
-
- entry['media_type'] = u'image' # heh
+
+ entry['media_type'] = u'image' # heh
entry['uploader'] = request.user['_id']
# Process the user's folksonomy "tags"
# We generate this ourselves so we know what the taks id is for
# retrieval later.
- # (If we got it off the task's auto-generation, there'd be a risk of
- # a race condition when we'd save after sending off the task)
+
+ # (If we got it off the task's auto-generation, there'd be
+ # a risk of a race condition when we'd save after sending
+ # off the task)
task_id = unicode(uuid.uuid4())
entry['queued_task_id'] = task_id
# expect a lot of users to run things in this way we have to
# capture stuff here.
#
- # ... not completely the diaper pattern because the exception is
- # re-raised :)
+ # ... not completely the diaper pattern because the
+ # exception is re-raised :)
mark_entry_failed(entry[u'_id'], exc)
# re-raise the exception
raise
add_message(request, SUCCESS, _('Woohoo! Submitted!'))
return redirect(request, "mediagoblin.user_pages.user_home",
- user = request.user['username'])
+ user=request.user['username'])
return render_to_response(
request,
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-
-
#if no data is available, return NotFound
if media_entries == None:
return render_404(request)
-
+
user_gallery_url = request.urlgen(
'mediagoblin.user_pages.user_gallery',
user=user['username'])
'media_entries': media_entries,
'pagination': pagination})
+
@uses_pagination
def user_gallery(request, page):
"""'Gallery' of a User()"""
#if no data is available, return NotFound
if media_entries == None:
return render_404(request)
-
+
return render_to_response(
request,
'mediagoblin/user_pages/gallery.html',
MEDIA_COMMENTS_PER_PAGE = 50
+
@get_user_media_entry
@uses_pagination
def media_home(request, media, page, **kwargs):
'Comment posted!')
return redirect(request, 'mediagoblin.user_pages.media_home',
- media = request.matchdict['media'],
- user = request.matchdict['user'])
+ media=request.matchdict['media'],
+ user=request.matchdict['user'])
@get_user_media_entry
ATOM_DEFAULT_NR_OF_UPDATED_ITEMS = 15
+
def atom_feed(request):
"""
generates the atom feed with the newest images
feed = AtomFeed(request.matchdict['user'],
feed_url=request.url,
url=request.host_url)
-
+
for entry in cursor:
feed.add(entry.get('title'),
entry.get('description_html'),
DISPLAY_IMAGE_FETCHING_ORDER = [u'medium', u'original', u'thumb']
TESTS_ENABLED = False
+
+
def _activate_testing():
"""
Call this to activate testing in util.py
def get_jinja_env(template_loader, locale):
"""
- Set up the Jinja environment,
+ Set up the Jinja environment,
(In the future we may have another system for providing theming;
for now this is good enough.)
def redirect(request, *args, **kwargs):
"""Returns a HTTPFound(), takes a request and then urlgen params"""
-
+
querystring = None
if kwargs.get('querystring'):
querystring = kwargs.get('querystring')
_punct_re = re.compile(r'[\t !"#$%&\'()*\-/<=>?@\[\\\]^_`{|},.]+')
+
def slugify(text, delim=u'-'):
"""
Generates an ASCII-only slug. Taken from http://flask.pocoo.org/snippets/5/
### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# We have two "test inboxes" here:
-#
+#
# EMAIL_TEST_INBOX:
# ----------------
# If you're writing test views, you'll probably want to check this.
# ***IMPORTANT!***
# ----------------
# Before running tests that call functions which send email, you should
-# always call _clear_test_inboxes() to "wipe" the inboxes clean.
+# always call _clear_test_inboxes() to "wipe" the inboxes clean.
EMAIL_TEST_INBOX = []
EMAIL_TEST_MBOX_INBOX = []
'to': to_addrs,
'message': message})
+
def _clear_test_inboxes():
global EMAIL_TEST_INBOX
global EMAIL_TEST_MBOX_INBOX
### </Special email test stuff>
### ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
def send_email(from_addr, to_addrs, subject, message_body):
"""
Simple email sending wrapper, use this so we can capture messages
# Split the tag string into a list of tags
for tag in stripped_tag_string.split(
- mg_globals.app_config['tags_delimiter']):
+ mg_globals.app_config['tags_delimiter']):
# Ignore empty or duplicate tags
if tag.strip() and tag.strip() not in [t['name'] for t in taglist]:
media_tag_string = ''
if media_entry_tags:
media_tag_string = mg_globals.app_config['tags_delimiter'].join(
- [tag['name'] for tag in media_entry_tags])
+ [tag['name'] for tag in media_entry_tags])
return media_tag_string
TOO_LONG_TAG_WARNING = \
u'Tags must be shorter than %s characters. Tags that are too long: %s'
+
def tag_length_validator(form, field):
"""
Make sure tags do not exceed the maximum tag length.
MARKDOWN_INSTANCE = markdown.Markdown(safe_mode='escape')
+
def cleaned_markdown_conversion(text):
"""
Take a block of text, run it through MarkDown, and clean its HTML.
SETUP_GETTEXTS = {}
+
def setup_gettext(locale):
"""
Setup the gettext instance based on this locale
PAGINATION_DEFAULT_PER_PAGE = 30
+
class Pagination(object):
"""
Pagination class for mongodb queries.
Args:
- page: requested page
- per_page: number of objects per page
- - cursor: db cursor
- - jump_to_id: ObjectId, sets the page to the page containing the object
- with _id == jump_to_id.
+ - cursor: db cursor
+ - jump_to_id: ObjectId, sets the page to the page containing the
+ object with _id == jump_to_id.
"""
self.page = page
self.per_page = per_page
self.active_id = jump_to_id
break
-
def __call__(self):
"""
Returns slice of objects for the requested page
last = num
def get_page_url_explicit(self, base_url, get_params, page_no):
- """
- Get a page url by adding a page= parameter to the base url
- """
+ """Get a page url by adding a page= parameter to the base url
+ """
new_get_params = copy.copy(get_params or {})
new_get_params['page'] = page_no
return "%s?%s" % (
base_url, urllib.urlencode(new_get_params))
def get_page_url(self, request, page_no):
- """
- Get a new page url based of the request, and the new page number.
+ """Get a new page url based of the request, and the new page number.
This is a nice wrapper around get_page_url_explicit()
- """
+ """
return self.get_page_url_explicit(
request.path_info, request.GET, page_no)
return render_to_response(
request, 'mediagoblin/404.html', {}, status=400)
+
def delete_media_files(media):
"""
Delete all files associated with a MediaEntry
from mediagoblin.db.util import DESCENDING
from mediagoblin.decorators import uses_pagination
+
@uses_pagination
def root_view(request, page):
cursor = request.db.MediaEntry.find(
def __unicode__(self):
return unicode(self.dir)
+
def __str__(self):
return str(self.dir)
+
def __repr__(self):
return repr(self.dir)
self.base_workbench_dir = os.path.abspath(base_workbench_dir)
if not os.path.exists(self.base_workbench_dir):
os.makedirs(self.base_workbench_dir)
-
+
def create_workbench(self):
"""
Create and return the path to a new workbench (directory).
if mo:
return mo.group(1)
else:
- raise RuntimeError("Unable to find version string in %s." % VERSIONFILE)
+ raise RuntimeError("Unable to find version string in %s." %
+ VERSIONFILE)
setup(
- name = "mediagoblin",
- version = get_version(),
+ name="mediagoblin",
+ version=get_version(),
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
zip_safe=False,
# scripts and dependencies
- install_requires = [
+ install_requires=[
'setuptools',
'PasteScript',
'beaker',
# 'lxml',
],
test_suite='nose.collector',
- entry_points = """\
+ entry_points="""\
[console_scripts]
gmg = mediagoblin.gmg_commands:main_cli
pybabel = mediagoblin.babel.messages.frontend:main
[babel.extractors]
jinja2 = jinja2.ext:babel_extract
""",
-
license='AGPLv3',
author='Free Software Foundation and contributors',
author_email='cwebber@gnu.org',
projects / mediagoblin.git / commitdiff