class TestCase(unittest.TestCase): def setUp(self): self.app = Flask(__name__) self.app.config['TESTING'] = True self.app.config['MONGODB_DATABASE'] = 'flask_testing' self.db = MongoKit(self.app) self.ctx = self.app.test_request_context('/') self.ctx.push() def tearDown(self): self.ctx.pop() def test_initialization(self): self.db.register([BlogPost]) assert len(self.db.registered_documents) > 0 assert self.db.registered_documents[0] == BlogPost assert isinstance(self.db, MongoKit) assert self.db.name == self.app.config['MONGODB_DATABASE'] assert isinstance(self.db.test, Collection) def test_property_connected(self): assert not self.db.connected self.db.connect() assert self.db.connected self.db.disconnect() assert not self.db.connected def test_bson_object_id_converter(self): converter = BSONObjectIdConverter("/") self.assertRaises(BadRequest, converter.to_python, ("132")) assert converter.to_python("4e4ac5cfffc84958fa1f45fb") == \ ObjectId("4e4ac5cfffc84958fa1f45fb") assert converter.to_url(ObjectId("4e4ac5cfffc84958fa1f45fb")) == \ "4e4ac5cfffc84958fa1f45fb" def test_save_and_find_document(self): self.db.register([BlogPost]) assert len(self.db.registered_documents) > 0 assert self.db.registered_documents[0] == BlogPost post = self.db.BlogPost() post.title = u"Flask-MongoKit" post.body = u"Flask-MongoKit is a layer between Flask and MongoKit" post.author = u"Christoph Heer" post.save() assert self.db.BlogPost.find().count() > 0 rec_post = self.db.BlogPost.find_one({'title': u"Flask-MongoKit"}) assert rec_post.title == post.title assert rec_post.body == rec_post.body assert rec_post.author == rec_post.author
app = Flask(__name__) class Task(Document): __collection__ = 'tasks' structure = { 'title': unicode, 'text': unicode, 'creation': datetime, } required_fields = ['title', 'creation'] default_values = {'creation': datetime.utcnow()} use_dot_notation = True db = MongoKit(app) db.register([Task]) @app.route('/') def show_all(): tasks = db.Task.find() return render_template('list.html', tasks=tasks) @app.route('/<ObjectId:task_id>') def show_task(task_id): task = db.Task.get_from_id(task_id) return render_template('task.html', task=task) @app.route('/new', methods=["GET", "POST"]) def new_task(): if request.method == 'POST': task = db.Task()
res = super(Word, self).find(newfilter, sort=[('url.token', pymongo.DESCENDING)]) if not res.count(): rndfilter['url.token'] = {'$gt': rnd} res = super(Word, self).find(newfilter, sort=[('url.token', pymongo.ASCENDING)]) return res def save(self, *args, **kwargs): self.url.slug = slugify(self.title) super(Word, self).save(*args, **kwargs) def to_es_json(self): """Convert this word to JSON for ElasticSearch.""" data = { 'title': self.title, 'definition': self.definition, 'tags': self.tags, } return json.dumps(data) @property def to_url(self): """(Relative) URL for this word.""" return url_for('detail', slug=self.url.slug, token=self.url.token) db = MongoKit(app) db.register([Word])
class TestCase(unittest.TestCase): def setUp(self): self.app = Flask(__name__) self.app.config['TESTING'] = True self.app.config['MONGODB_DATABASE'] = 'flask_testing' maybe_conf_file = os.path.join(os.getcwd(), "config_test.cfg") if os.path.exists(maybe_conf_file): self.app.config.from_pyfile(maybe_conf_file) self.db = MongoKit(self.app) self.ctx = self.app.test_request_context('/') self.ctx.push() def tearDown(self): self.ctx.pop() def test_initialization(self): self.db.register([BlogPost]) assert len(self.db.registered_documents) > 0 assert self.db.registered_documents[0] == BlogPost assert isinstance(self.db, MongoKit) assert self.db.name == self.app.config['MONGODB_DATABASE'] assert isinstance(self.db.test, Collection) def test_decorator_registration(self): @self.db.register class DecoratorRegistered(Document): pass assert len(self.db.registered_documents) > 0 assert self.db.registered_documents[0] == DecoratorRegistered def test_property_connected(self): assert not self.db.connected self.db.connect() assert self.db.connected self.db.disconnect() assert not self.db.connected def test_bson_object_id_converter(self): converter = BSONObjectIdConverter("/") self.assertRaises(BadRequest, converter.to_python, ("132")) assert converter.to_python("4e4ac5cfffc84958fa1f45fb") == \ ObjectId("4e4ac5cfffc84958fa1f45fb") assert converter.to_url(ObjectId("4e4ac5cfffc84958fa1f45fb")) == \ "4e4ac5cfffc84958fa1f45fb" def test_save_and_find_document(self): self.db.register([BlogPost]) assert len(self.db.registered_documents) > 0 assert self.db.registered_documents[0] == BlogPost post = self.db.BlogPost() post.title = u"Flask-MongoKit" post.body = u"Flask-MongoKit is a layer between Flask and MongoKit" post.author = u"Christoph Heer" post.save() assert self.db.BlogPost.find().count() > 0 rec_post = self.db.BlogPost.find_one({'title': u"Flask-MongoKit"}) assert rec_post.title == post.title assert rec_post.body == rec_post.body assert rec_post.author == rec_post.author def test_get_or_404(self): self.db.register([BlogPost]) assert len(self.db.registered_documents) > 0 assert self.db.registered_documents[0] == BlogPost post = self.db.BlogPost() post.title = u"Flask-MongoKit" post.body = u"Flask-MongoKit is a layer between Flask and MongoKit" post.author = u"Christoph Heer" post.save() assert self.db.BlogPost.find().count() > 0 assert "get_or_404" in dir(self.db.BlogPost) try: self.db.BlogPost.get_or_404(post['_id']) except NotFound: self.fail("There should be a document with this id") self.assertRaises(NotFound, self.db.BlogPost.get_or_404, ObjectId()) def test_find_one_or_404(self): self.db.register([BlogPost]) assert len(self.db.registered_documents) > 0 assert self.db.registered_documents[0] == BlogPost post = self.db.BlogPost() post.title = u"Flask-MongoKit" post.body = u"Flask-MongoKit is a layer between Flask and MongoKit" post.author = u"Christoph Heer" post.save() assert self.db.BlogPost.find().count() > 0 assert "find_one_or_404" in dir(self.db.BlogPost) try: self.db.BlogPost.find_one_or_404({'title': u'Flask-MongoKit'}) except NotFound: self.fail("There should be a document with this title") self.assertRaises(NotFound, self.db.BlogPost.find_one_or_404, {'title': u'Flask is great'})
class Database(): """ Represents a connection to a MongoDB database. """ def __init__(self, app): """ Takes in a Flask app and initializes a connection to a MongoDB database. """ self._app = app self._mk = MongoKit(self._app) self._mk.register(MODELS) def _drop_contents(self): """ Drops all collections in the database. Only manage.py should call this! """ for database_name in self._mk.connection.database_names(): db = self._mk.connection[database_name] try: self._mk.connection.drop_database(database_name) except: # This is a system database, leave it alone! pass def _show_contents(self): """ Shows the contents of the current MongoDB connection. (jven) """ for database_name in self._mk.connection.database_names(): print 'DATABASE: %s' % database_name db = self._mk.connection[database_name] for collection_name in db.collection_names(): print 'COLLECTION: %s' % collection_name collection = db[collection_name] count = collection.count() if count == 1: print '%d document' % collection.count() else: print '%d documents' % collection.count() def _show_contents_lengthy(self): """ Shows the contents of the current MongoDB connection. (pwoods) """ for database_name in self._mk.connection.database_names(): print 'DATABASE: %s\n' % database_name db = self._mk.connection[database_name] for collection_name in db.collection_names(): print 'COLLECTION: %s' % collection_name collection = db[collection_name] count = collection.count() curs = collection.find() for row in curs: for key in row: print key, ':', row[key] print '\n' def user_exists(self, email): """ Takes an e-mail address and checks if a User exists with that address. """ return self._mk.User.find_one({'email':email}) is not None def get_user_and_login(self, email, raw_password): """ Takes an e-mail address and password and checks if a User exists with this combination. Updates date_last_login if user exists, None otherwise. """ password = get_hashed_password(raw_password) user = self._mk.User.find_one({'email':email, 'password':password}) if user is not None: user.date_last_login = get_unicode_datetime() user.save() return user def get_user_by_id(self, user_id): """ Takes a user id (unicode) and returns the User corresponding to that id. Returns None if no such user exists. """ if type(user_id) != unicode: return None try: return self._mk.User.find_one(ObjectId(user_id)) except: return None def make_user(self, name, email, raw_password): """ Takes in a user's information and makes a document in the table representing the user. Requires not user_exists(email). Returns the user. """ assert not self.user_exists(email), ( 'ASSERTION ERROR: User exists with email \'%s\'!' % email) new_user = self._mk.User() new_user.name = name new_user.email = email password = get_hashed_password(raw_password) new_user.password = password new_user.date_created = get_unicode_datetime() new_user.date_last_login = get_unicode_datetime() new_user.bookmark_sort_key = DEFAULT_BOOKMARK_SORT_KEY new_user.bookmark_sort_order = DEFAULT_BOOKMARK_SORT_ORDER new_user.save() return new_user def bookmark_exists(self, user_id, url): """ Takes in a user and a url and returns whether the user has a bookmark with the url. """ return self._mk.Bookmark.find_one( {'owner':unicode(user_id), 'url':url}) is not None def click_bookmark(self, bookmark_id): """ Get a bookmark and record a click for that bookmark. Returns the bookmark. """ bookmark = self.get_bookmark(unicode(bookmark_id)) assert bookmark is not None, ('ASSERTION ERROR: Attempted to click an ' 'invalid bookmark.') bookmark.clicks += 1 bookmark.date_last_clicked = get_unicode_datetime() bookmark.save() return bookmark def get_bookmark(self, bookmark_id): """ Gets the book corresponding to the given bookmark_id. """ if type(bookmark_id) != unicode: return None try: return self._mk.Bookmark.find_one(ObjectId(bookmark_id)) except: return None def get_all_bookmarks(self, user_id, sort_by): """ Gets a user's bookmarks, sorted in the specified way. Returns an empty list if no such user exists. """ user = self.get_user_by_id(user_id) if user is None: return [] user.bookmark_sort_key, user.bookmark_sort_order = sort_by return self._mk.Bookmark.find({'owner':unicode(user_id)}).sort([sort_by]) def make_bookmark(self, user_id, url): """ Makes a bookmark for the given user with the given url. Requires not bookmark_exists(user, url). Returns the bookmark. """ assert not self.bookmark_exists(user_id, url), ('ASSERTION ERROR: ' 'A bookmark already exists with the given URL for that user.') new_bookmark = self._mk.Bookmark() new_bookmark.url = url new_bookmark.owner = unicode(user_id) new_bookmark.date_created = get_unicode_datetime() new_bookmark.clicks = 0 new_bookmark.save() return new_bookmark def delete_bookmark(self, bookmark_id): """ Removes a bookmark from every circle it's in, then deletes the bookmark. """ bookmark = self.get_bookmark(bookmark_id) assert bookmark is not None for circle_id in bookmark.circles: circle = self.get_circle(circle_id) circle.bookmarks.remove(bookmark_id) circle.save() self._mk.Bookmark.collection.remove(ObjectId(bookmark_id)) def delete_circle(self, circle_id): """ Deletes the circle corresponding to the given circle_id. The bookmarks in the circle are not deleted. """ circle = self.get_circle(circle_id) assert circle is not None, 'ASSERTION ERROR: No such circle exists.' for bookmark_id in circle.bookmarks: bookmark = self.get_bookmark(bookmark_id) bookmark.circles.remove(circle_id) bookmark.save() self._mk.Circle.collection.remove(ObjectId(circle_id)) def circle_exists(self, user_id, name): """ Takes a user and a circle name and checks if the user has a circle with that name. """ return self._mk.Circle.find_one( {'owner':unicode(user_id), 'name':name}) is not None def get_circle(self, circle_id): """ Gets the circle corresponding to the given circle_id, or None if no such circle exists. """ if type(circle_id) != unicode: return None try: return self._mk.Circle.find_one(ObjectId(circle_id)) except: return None def get_all_circles(self, user_id): """ Gets a user's circles. """ return self._mk.Circle.find({'owner':unicode(user_id)}) def make_circle(self, user_id, name): """ Makes a circle for the given user with the given name. Requires not circle_exists(user, name). Returns the circle. """ assert not self.circle_exists(user_id, name), ('ASSERTION ERROR: ' 'A circle already exists for this user with that name.') new_circle = self._mk.Circle() new_circle.name = name new_circle.owner = unicode(user_id) new_circle.date_created = get_unicode_datetime() new_circle.save() return new_circle def edit_circle(self, user_id, name, new_name): """ Changes the name of the given circle, if the new name has not already been taken. """ assert self.circle_exists(user_id, name), ('ASSERTION ERROR: ' 'A circle with that name does not exist for this user.') assert not self.circle_exists(user_id, new_name), ('ASSERTION ERROR: ' 'A circle already eixsts for this user with that name.') circle = self._mk.Circle.find_one( {'owner':unicode(user_id), 'name':name}) assert circle.owner == unicode(user_id), ('ASSERTION ERROR: ' 'User does not own that circle.') circle.name = new_name circle.save() return circle def get_bookmarks_in_circle(self, user_id, circle_id, sort_by): """ Gets all the bookmarks in the circle in the specified sort order. Requires bookmark_exists(url) for each url in circle.bookmarks. """ user = self.get_user_by_id(user_id) assert user is not None, 'ASSERTION ERROR: No such user exists.' user.bookmark_sort_key, user.bookmark_sort_order = sort_by circle = self.get_circle(circle_id) assert circle.owner == unicode(user_id), ('ASSERTION ERROR: User does ' 'not own this circle.') if circle is None: return [] return self._mk.Bookmark.find({ '_id': {'$in': [ObjectId(bookmark_id) for bookmark_id in circle.bookmarks] } }).sort([sort_by]) def is_bookmark_in_circle(self, bookmark_id, circle_id): """ Returns whether a bookmark is in a circle. """ bookmark = self.get_bookmark(bookmark_id) circle = self.get_circle(circle_id) if bookmark is None or circle is None: return False if (unicode(bookmark._id) in circle.bookmarks or unicode(circle._id) in bookmark.circles): return True else: return False def add_bookmark_to_circle(self, bookmark_id, circle_id): """ Takes a bookmark and circle and adds the bookmark to the circle. Updates suggestions. """ assert not self.is_bookmark_in_circle(bookmark_id, circle_id), ( 'ASSERTION ERROR: That bookmark is already in that circle.') bookmark = self.get_bookmark(bookmark_id) circle = self.get_circle(circle_id) if bookmark is None or circle is None: return bookmark.circles.append(unicode(circle_id)) bookmark.save() circle.bookmarks.append(unicode(bookmark_id)) circle.save() def remove_bookmark_from_circle(self, bookmark_id, circle_id): """ Takes a bookmark and circle and removes the bookmark from the circle. """ assert self.is_bookmark_in_circle(bookmark_id, circle_id), ( 'ASSERTION ERROR: That bookmark is not in that circle.') bookmark = self.get_bookmark(bookmark_id) circle = self.get_circle(circle_id) if bookmark is None or circle is None: return bookmark.circles.remove(unicode(circle_id)) bookmark.save() circle.bookmarks.remove(unicode(bookmark_id)) circle.save() def get_suggestions(self, user_id, limit): """ Returns a list of |limit| or less suggested bookmarks using data for other users. """ suggestions = [] user_id = unicode(user_id) if limit == 0: return suggestions user_bookmarks = self._mk.Bookmark.find( {'owner':user_id}) user_bookmarks = [u_b for u_b in user_bookmarks] user_urls = [u_b.url for u_b in user_bookmarks] for bookmark in user_bookmarks: same_urls = self._mk.Bookmark.find( {'url': bookmark.url }) for same_url in same_urls: if same_url.owner == user_id: continue for circle_id in same_url.circles: circle = self.get_circle(circle_id) for suggested_id in circle.bookmarks: suggestion = self.get_bookmark(suggested_id) if suggestion.url in user_urls: continue if suggestion.url in suggestions: continue suggestions.append(suggestion.url) if len(suggestions) >= limit: return suggestions return suggestions def check_parameters(self, user_id, bookmark_id, circle_id): """ Checks that: - |bookmark_id| is a non-empty id - |circle_id| is a non-empty id - the user owns a bookmark with the given id - the user owns a circle with the given id Returns an error if a check fails, or None if all checks pass """ if not bookmark_id: return 'Invalid bookmark ID.' if not circle_id: return 'Invalid circle ID.' bookmark = self.get_bookmark(bookmark_id) if bookmark is None: return 'Invalid bookmark.' circle = self.get_circle(circle_id) if circle is None: return 'Invalid circle.' if bookmark.owner != user_id: return 'You don\'t own that bookmark.' if circle.owner != user_id: return 'You don\'t own that circle.' return None
from flask import g from flask import render_template from flask import request from flask import session from flask import render_template from hyperpublic import Hyperpublic from models import CreditCard from models import User from flaskext.mongokit import MongoKit app = Flask(__name__) app.debug = True app.secret_key = 'omnomnom' db = MongoKit(app) db.register([CreditCard, User]) HYPERPUBLIC_KEY = 'eDuglow1SWQZjKFm58yUD2ZwBb2Tqfdem8ZgDnQP' HYPERPUBLIC_SECRET = 'iouuCxwLmjSFgDCwlG0nQW5XwqHMSnbRQw7X54zT' ORDRIN_API_KEY = 'pni78Hs4BGdV-pFu8bTaA' hp_client = Hyperpublic(HYPERPUBLIC_KEY, HYPERPUBLIC_SECRET) @app.before_request def before_request(): if 'logged_in_id' in session: g.logged_in_user = db.User.find_one(session['logged_in_id']) else: g.logged_in_user = None @app.route('/', methods=['GET'])