def save(user):
if user.anonymous:
return
buid = ObjectId(user.sysid)
user_doc = { '_id': buid, 'name': user.name, 'chances': user.chances }
database = connection()
database.accounts.save(user_doc)
def log():
user = users.current()
if user.anonymous:
abort(401)
query = { 'user.id': ObjectId(user.sysid) }
database = connection();
videos = database.screening.find(query)
history_flat = []
for video in videos:
history_flat.append(dict(
title = video['video']['title'],
datetime = video['_id'].generation_time,
date = video['_id'].generation_time.strftime('%B %d'),
time = video['_id'].generation_time.strftime('%H:%M'),
type = 'video'
))
query = { 'author.id': ObjectId(user.sysid) }
comments = database.comments.find(query)
for comment in comments:
history_flat.append(dict(
title = comment['text'],
datetime = comment['_id'].generation_time,
date = comment['_id'].generation_time.strftime('%B %d'),
time = comment['_id'].generation_time.strftime('%H:%M'),
type = 'comment'
))
history = OrderedDict()
orderkey = lambda item: item['datetime']
for item in sorted(history_flat, key=orderkey, reverse=True):
history.setdefault(item['date'], []).append(item)
g.profile_menu['active'] = 'log'
return render_template('devel/log.html', history=history)
def setUp(self):
comment = {
'author': {
'id': ObjectId('5105246814867019544b45e7'),
'name': 'vadim'
},
'text': 'I feel free!',
'review': 'unknown',
'video': {
'id': ObjectId('5129e49971eeccbbcaf90805'),
'title': 'Snapple "Lighter Fruit"'
},
'likes': [
ObjectId('5105246814867019544b45e7')
],
'time': 28.823
}
user = {
'name': 'test user: {0}'.format(repr(self)),
'chances': 123
}
video = {
'duration' : 22,
'random' : 0.31461311114729994,
'vimeoid' : 24879869,
'description' : 'The story of a cartoon character',
'title' : 'Overcast'
}
self.database = connection()
self.comment_id = str(self.database.comments.insert(comment))
self.user_id = str(self.database.accounts.insert(user))
self.video_id = str(self.database.videos.insert(video))
def unlike(comment, user):
database = connection()
comment._likes -= 1
comment.liked = False
comment_id = ObjectId(comment.sysid)
user_id = ObjectId(user.sysid)
database.comments.update({'_id': comment_id},
{'$pop': {'likes': user_id}})
def random():
'''Get one random video resource from storage.'''
database = connection()
rand = rndm.random()
found = database.videos.find_one({'random': {'$gte': rand}})
if not found:
found = database.videos.find_one({'random': {'$lt': rand}})
return _video_from_dict(found)
def setUp(self):
username = '******'.format(repr(self))
test_user = dict(name=username, chances=222)
self.database = connection()
self.user_id = str(self.database.accounts.insert(test_user))
class TestConf(AppConfig):
TESTING = True
self.app = create_app(TestConf)
def like(comment, user):
database = connection()
comment._likes += 1
comment.liked = True
comment_id = ObjectId(comment.sysid)
user_id = ObjectId(user.sysid)
database.comments.update({'_id': comment_id},
{'$addToSet': {'likes': user_id}})
def find(resource_id):
'''Find the video resource in the storage by it's identifier.'''
resource_id = ObjectId(resource_id)
database = connection()
found = database.videos.find_one(resource_id)
if not found:
return None
return _video_from_dict(found)
def find(user_id):
user_id = ObjectId(user_id)
database = connection()
user_doc = database.accounts.find_one(user_id)
if not user_doc:
return None
sysid = str(user_doc['_id'])
username = user_doc['name']
chances = user_doc.get('chances', 0)
return User(sysid, username, chances)
def setUp(self):
'''Store sample video for tests'''
data = {
'duration' : 22,
'random' : 0.31461311114729994,
'vimeoid' : 24879869,
'description' : 'The story of a cartoon character',
'title' : 'Overcast'
}
self.database = connection()
self.video_id = str(self.database.videos.insert(data))
def screening_log(user, video):
if user.anonymous:
return None
buid = ObjectId(user.sysid)
rec = {
'user': { 'id': buid, 'name': user.display_name },
'video': { 'id': video.sysid, 'title': video.title }
}
database = connection()
screening_id = database.screening.insert(rec)
database.accounts.update({ '_id': buid }, { '$inc': { 'chances': 1 } })
return str(screening_id)
def setUp(self):
test = self
class TestWebClient(object):
def receive_tokens(self, code):
return dict(access_token='test_access_token')
def user_info(self, access_token):
return dict(id=test.user_id, username=test.username)
self.webclient_mock = TestWebClient()
self.database = connection()
self.service = AuthService('some_auth_code')
class TestConf(AppConfig):
TESTING = True
self.app = create_app(TestConf)
def setUp(self):
self.test_user_name = 'test user: {0}'.format(repr(self))
test_user = {'name': self.test_user_name, 'chances': 222}
self.database = connection()
uid = self.database.accounts.save(test_user)
self.test_user_id = str(uid)
video = {
'duration' : 22,
'random' : 0.31461311114729994,
'vimeoid' : 24879869,
'description' : 'The story of a cartoon character',
'title' : 'Overcast'
}
self.video_id = str(self.database.videos.insert(video))
def setUp(self):
test = self
username = '******'.format(repr(self))
test_user = dict(name=username, chances=222)
self.database = connection()
self.user_id = str(self.database.accounts.insert(test_user))
class TestWebClient(object):
def receive_tokens(self, code):
return dict(access_token='test_access_token')
def user_info(self, access_token):
return dict(id=test.user_id, username=username)
self.webclient_mock = TestWebClient()
class TestConf(AppConfig):
TESTING = True
self.app = create_app(TestConf).test_client()
def setUp(self):
self.database = connection()
user = {
'name': 'test user: {0}'.format(repr(self)),
'chances': 123
}
video = {
'duration' : 65,
'random' : 0.31461311114729994,
'vimeoid' : 24879869,
'description' : 'The story of a cartoon character',
'title' : 'Overcast'
}
user_id = str(self.database.accounts.insert(user))
video_id = str(self.database.videos.insert(video))
self.video = videos.find(video_id)
self.user = users.find(user_id)
def new_comment(video, user, text, time):
comment = {
'author': {
'id': ObjectId(user.sysid),
'name': user.display_name
},
'text': text,
'review': 'approved',
'video': {
'id': ObjectId(video.sysid),
'title': video.title
},
'time': time
}
database = connection()
comment['_id'] = database.comments.insert(comment)
return _construct(comment)
def setUp(self):
video_data = {
'duration' : 22,
'random' : 0.31461311114729994,
'vimeoid' : 24879869,
'description' : 'The story of a cartoon character',
'title' : 'Overcast'
}
self.database = connection()
self.video_id = str(self.database.videos.insert(video_data))
test_user_name = 'test user: {0}'.format(repr(self))
test_user = dict(name=test_user_name, chances=222)
uid = self.database.accounts.save(test_user)
self.test_user_id = str(uid)
redis_url = os.environ.get('REDISTOGO_URL')
url = urlparse(redis_url)
self.redis = StrictRedis(host=url.hostname, port=url.port,
password=url.password)
self.prefix = 'watch-transaction:'
def videos():
database = connection();
videos = list(database.videos.find())
# found = set()
# for video in videos:
# if video['title'] in found:
# database.videos.remove(video['_id'])
# else:
# found.add(video['title'])
# videos = list(database.videos.find())
for video in videos:
query = { 'video.id': video['_id'] }
comments = list(database.comments.find(query))
video['comments'] = len(comments)
video['likes'] = 0;
for comment in comments:
video['likes'] += len(comment.get('likes', []))
g.profile_menu['active'] = 'videos'
return render_template('devel/videos.html', videos=videos)
def raffle():
database = connection();
allusers = list(database.accounts.find())
tokens = []
for user in allusers:
tokens.extend([user['_id']] * user.get('chances', 0))
total_tokens = len(tokens)
target_tokens = int(round(total_tokens * 0.1))
wons = defaultdict(int)
for _ in range(target_tokens):
token = random.choice(tokens)
wons[token] += 1
curr_user = users.current()
total_sum = random.randint(20000, 30000)
token_sum = float(total_sum) / target_tokens
for user in allusers:
user['wons'] = wons[user['_id']]
user['sum'] = int(round(user['wons'] * token_sum))
if (curr_user.sysid == str(user['_id'])):
user['curr'] = True
g.profile_menu['active'] = 'raffle'
return render_template('devel/raffle.html', users=allusers,
total_sum=total_sum)
def for_screening(video, user):
database = connection()
query = {'video.id': ObjectId(video.sysid), 'review': 'approved'}
fields = {'time': 1}
frame_length = 5 # seconds
start_offset = 3 # seconds
comids = list(database.comments.find(query, fields))
marks = _create_time_marks(video.duration, frame_length, start_offset)
comids = {com['_id']: com for com in _get_random_comments(comids, marks)}
selcoms_query = {'_id': {'$in': list(iter(comids))}}
selcoms = list(database.comments.find(selcoms_query))
usid = user.sysid
if not user.anonymous:
usid = ObjectId(user.sysid)
for com in selcoms:
liked = 'likes' in com and usid in com['likes']
comids[com['_id']]['liked'] = liked
selcoms = [_construct(comment) for comment in selcoms]
selcoms = sorted(selcoms, key=lambda com: com.sysid)
for com in selcoms:
commid = ObjectId(com.sysid)
com.start = comids[commid]['start']
com.liked = comids[commid]['liked']
selcoms = sorted(selcoms, key=lambda com: com.start)
start_message = 'Feel free to comment, please!'
start_message = _system_comment(start_message, video)
start_message.start = 0;
selcoms.insert(0, start_message)
selcoms_len = len(selcoms)
if selcoms_len > 1 and selcoms_len <= len(marks):
end_message = 'There is no more comments for this video. ' \
'You can write the brief about.'
end_message = _system_comment(end_message, video)
end_message.start = selcoms[-1].start + frame_length
selcoms.append(end_message)
return selcoms
def spam(comment):
database = connection()
comment._review = 'forbidden'
comment_id = ObjectId(comment.sysid)
database.comments.update({'_id': comment_id},
{'$set': {'review': comment._review}})
def find(comment_id):
database = connection()
dbdata = database.comments.find_one(ObjectId(comment_id))
if not dbdata:
return None
return _construct(dbdata)
def approve(comment):
database = connection()
comment._review = 'approved'
comment_id = ObjectId(comment.sysid)
database.comments.update({'_id': comment_id},
{'$set': {'review': comment._review}})
