def get_dbs(cls, query=None, order=None, limit=None, cursor=None, **kwgs):
return util.retrieve_dbs(query or cls.query(),
limit=limit or util.param('limit', int),
cursor=cursor or util.param('cursor'),
order=order or util.param('order')
or '-created',
**kwgs)
def welcome():
if util.param('username'):
return flask.redirect(flask.url_for('gh_account', username=util.param('username')))
person_dbs, person_cursor = model.Account.get_dbs(
order='-stars',
organization=False,
)
organization_dbs, organization_cursor = model.Account.get_dbs(
order='-stars',
organization=True,
)
repo_dbs, repo_cursor = model.Repo.get_dbs(
order='-stars',
)
return flask.render_template(
'welcome.html',
html_class='welcome',
title='Top People, Organizations and Repositories',
person_dbs=person_dbs,
organization_dbs=organization_dbs,
repo_dbs=repo_dbs,
)
def filter_update(filter_id=''):
if filter_id:
filter_db = model.Filter.get_by_id(filter_id)
else:
filter_db = model.Filter(
id='{}-{}'.format(util.param('filter_value'), util.param('filter_value')),
label='')
if not filter_db or not auth.current_user_db().admin:
return flask.abort(404)
form = FilterUpdateForm(obj=filter_db)
if form.validate_on_submit():
form.populate_obj(filter_db)
filter_db.put()
return flask.redirect(flask.url_for('admin_filter_list'))
return flask.render_template(
'filter/filter_update.html',
html_class='filter-update',
title='%s' % (filter_db.label or 'فلتر جديد'),
filter_db=filter_db,
form=form,
api_url=flask.url_for('api.filter', key=filter_db.key.urlsafe()) if filter_db.key else '',
)
def post(self, track_key):
"""Updates a specific Track"""
b_track = ndb.Key(urlsafe=track_key).get()
if b_track and util.param('name') and util.param('courses'):
b_name = util.param('name')
b_description = util.param('description')
b_topics = [ ndb.Key(urlsafe=topic_key_url) for topic_key_url in util.param('topics', list)]
b_courses = helpers.connected_entities_constructor([ ndb.Key(urlsafe=course_key_url) for course_key_url in util.param('courses', list)])
b_contributors = b_track.contributors
#add new contributors to the list of track contributors.
if auth.current_user_key() not in b_contributors:
b_contributors += [auth.current_user_key()]
b_track.name=b_name
b_track.description=b_description
b_track.topics=b_topics
b_track.contributors=b_contributors
b_track.courses=b_courses
b_track = b_track.put()
response = {
'status': 'success',
'count': 1,
'now': helpers.time_now(),
'result': {'message': 'track was successfuly created!!',
'view_url': flask.url_for('track', track_key=b_track.urlsafe())
},
}
return response
return helpers.make_bad_request_exception("Unsifificient parameters")
def organization():
limit = min(
int(
util.param('limit', int) or flask.request.cookies.get('limit')
or config.MAX_DB_LIMIT), config.MAX_DB_LIMIT)
order = util.param('order') or '-stars'
if 'repo' in order:
order = '-public_repos'
organization_dbs, organization_cursor = model.Account.get_dbs(
order=order,
organization=True,
limit=limit,
)
response = flask.make_response(
flask.render_template(
'account/list_organization.html',
title='Organizations',
description='Top Organizations on GitHub',
html_class='account-organization',
organization_dbs=organization_dbs,
order=order,
limit=limit,
))
response.set_cookie('limit', str(limit))
return response
def get_dbs(cls, admin=None, active=None, permissions=None, **kwargs):
return super(User, cls).get_dbs(
admin=admin or util.param('admin', bool),
active=active or util.param('active', bool),
permissions=permissions or util.param('permissions', list),
**kwargs
)
def repo():
limit = min(
int(
util.param('limit', int) or flask.request.cookies.get('limit')
or config.MAX_DB_LIMIT), config.MAX_DB_LIMIT * 4)
order = util.param('order') or '-stars'
if 'fork' in order:
order = '-forks'
repo_dbs, repo_cursor = model.Repo.get_dbs(
order=order,
limit=limit,
)
response = flask.make_response(
flask.render_template(
'account/list_repo.html',
title='Repositories',
description='Top Repositories on GitHub',
html_class='account-repo',
repo_dbs=repo_dbs,
order=order.replace('-', ''),
limit=limit,
))
response.set_cookie('limit', str(limit))
return response
def gh_admin_top():
if config.PRODUCTION and 'X-Appengine-Cron' not in flask.request.headers:
flask.abort(403)
stars = util.param('stars', int) or 10000
page = util.param('page', int) or 1
per_page = util.param('per_page', int) or 100
# TODO: fix formatting
result = urlfetch.fetch('https://api.github.com/search/repositories?q=stars:>=%s&sort=stars&order=asc&page=%d&per_page=%d' % (stars, page, per_page))
if result.status_code == 200:
repos = json.loads(result.content)
else:
flask.abort(result.status_code)
for repo in repos['items']:
account = repo['owner']
account_db = model.Account.get_or_insert(
account['login'],
avatar_url=account['avatar_url'].split('?')[0],
email=account['email'] if 'email' in account else '',
name=account['login'],
followers=account['followers'] if 'followers' in account else 0,
organization=account['type'] == 'Organization',
username=account['login'],
)
return 'OK %d of %d' % (len(repos['items']), repos['total_count'])
def get_dbs(cls, admin=None, active=None, permissions=None, **kwargs):
return super(User, cls).get_dbs(
admin=admin or util.param('admin', bool),
active=active or util.param('active', bool),
permissions=permissions or util.param('permissions', list),
**kwargs
)
def welcome():
if util.param('username'):
return flask.redirect(
flask.url_for('gh_account', username=util.param('username')))
person_dbs, person_cursor = model.Account.get_dbs(
order='-stars',
organization=False,
)
organization_dbs, organization_cursor = model.Account.get_dbs(
order='-stars',
organization=True,
)
repo_dbs, repo_cursor = model.Repo.get_dbs(order='-stars', )
return flask.render_template(
'welcome.html',
html_class='welcome',
title='Top People, Organizations and Repositories',
description='Discover new projects from a different perspective.',
person_dbs=person_dbs,
organization_dbs=organization_dbs,
repo_dbs=repo_dbs,
)
def get_dbs(cls, **kwgs):
return super(User, cls).get_dbs(
admin=util.param('admin', bool),
active=util.param('active', bool),
permissions=util.param('permissions', list),
**kwgs
)
def gh_admin_top():
if config.PRODUCTION and 'X-Appengine-Cron' not in flask.request.headers:
flask.abort(403)
stars = util.param('stars', int) or 10000
page = util.param('page', int) or 1
per_page = util.param('per_page', int) or 100
# TODO: fix formatting
result = urlfetch.fetch(
'https://api.github.com/search/repositories?q=stars:>=%s&sort=stars&order=asc&page=%d&per_page=%d'
% (stars, page, per_page))
if result.status_code == 200:
repos = json.loads(result.content)
else:
flask.abort(result.status_code)
for repo in repos['items']:
account = repo['owner']
account_db = model.Account.get_or_insert(
account['login'],
avatar_url=account['avatar_url'].split('?')[0],
email=account['email'] if 'email' in account else '',
name=account['login'],
followers=account['followers'] if 'followers' in account else 0,
organization=account['type'] == 'Organization',
username=account['login'],
)
return 'OK %d of %d' % (len(repos['items']), repos['total_count'])
def person():
limit = int(
util.param('limit', int) or flask.request.cookies.get('limit')
or config.MAX_DB_LIMIT)
order = util.param('order') or '-stars'
if 'repo' in order:
order = '-public_repos'
elif 'follower' in order:
order = '-followers'
person_dbs, person_cursor = model.Account.get_dbs(
order=order,
organization=False,
limit=limit,
)
response = flask.make_response(
flask.render_template(
'account/list_person.html',
title='Top People',
html_class='account-person',
person_dbs=person_dbs,
order=order,
limit=limit,
))
response.set_cookie('limit', str(limit))
return response
def user_merge():
user_keys = util.param('user_keys', list)
if not user_keys:
flask.abort(400)
user_db_keys = [ndb.Key(urlsafe=k) for k in user_keys]
user_dbs = ndb.get_multi(user_db_keys)
if len(user_dbs) < 2:
flask.abort(400)
if flask.request.path.startswith('/_s/'):
return util.jsonify_model_dbs(user_dbs)
user_dbs.sort(key=lambda user_db: user_db.created)
merged_user_db = user_dbs[0]
auth_ids = []
permissions = []
is_admin = False
is_active = False
for user_db in user_dbs:
auth_ids.extend(user_db.auth_ids)
permissions.extend(user_db.permissions)
is_admin = is_admin or user_db.admin
is_active = is_active or user_db.active
if user_db.key.urlsafe() == util.param('user_key'):
merged_user_db = user_db
auth_ids = sorted(list(set(auth_ids)))
permissions = sorted(list(set(permissions)))
merged_user_db.permissions = permissions
merged_user_db.admin = is_admin
merged_user_db.active = is_active
form_obj = copy.deepcopy(merged_user_db)
form_obj.user_key = merged_user_db.key.urlsafe()
form_obj.user_keys = ','.join(user_keys)
form = UserMergeForm(obj=form_obj)
if form.validate_on_submit():
form.populate_obj(merged_user_db)
merged_user_db.auth_ids = auth_ids
merged_user_db.put()
deprecated_keys = [
key for key in user_db_keys if key != merged_user_db.key
]
merge_user_dbs(merged_user_db, deprecated_keys)
return flask.redirect(
flask.url_for('user_update', user_id=merged_user_db.key.id()), )
return flask.render_template(
'user/user_merge.html',
title='Merge Users',
html_class='user-merge',
user_dbs=user_dbs,
merged_user_db=merged_user_db,
form=form,
auth_ids=auth_ids,
)
def user_merge():
user_keys = util.param('user_keys', list)
if not user_keys:
flask.abort(400)
user_db_keys = [ndb.Key(urlsafe=k) for k in user_keys]
user_dbs = ndb.get_multi(user_db_keys)
if len(user_dbs) < 2:
flask.abort(400)
if flask.request.path.startswith('/_s/'):
return util.jsonify_model_dbs(user_dbs)
user_dbs.sort(key=lambda user_db: user_db.created)
merged_user_db = user_dbs[0]
auth_ids = []
permissions = []
is_admin = False
is_active = False
for user_db in user_dbs:
auth_ids.extend(user_db.auth_ids)
permissions.extend(user_db.permissions)
is_admin = is_admin or user_db.admin
is_active = is_active or user_db.active
if user_db.key.urlsafe() == util.param('user_key'):
merged_user_db = user_db
auth_ids = sorted(list(set(auth_ids)))
permissions = sorted(list(set(permissions)))
merged_user_db.permissions = permissions
merged_user_db.admin = is_admin
merged_user_db.active = is_active
merged_user_db.verified = False
form_obj = copy.deepcopy(merged_user_db)
form_obj.user_key = merged_user_db.key.urlsafe()
form_obj.user_keys = ','.join(user_keys)
form = UserMergeForm(obj=form_obj)
if form.validate_on_submit():
form.populate_obj(merged_user_db)
merged_user_db.auth_ids = auth_ids
merged_user_db.put()
deprecated_keys = [k for k in user_db_keys if k != merged_user_db.key]
merge_user_dbs(merged_user_db, deprecated_keys)
return flask.redirect(
flask.url_for('user_update', user_id=merged_user_db.key.id()),
)
return flask.render_template(
'user/user_merge.html',
title='Merge Users',
html_class='user-merge',
user_dbs=user_dbs,
merged_user_db=merged_user_db,
form=form,
auth_ids=auth_ids,
)
def get_dbs(cls, query=None, ancestor=None, order=None, limit=None, cursor=None, **kwargs):
return util.get_dbs(
query or cls.query(ancestor=ancestor),
limit=limit or util.param('limit', int),
cursor=cursor or util.param('cursor'),
order=order or util.param('order') or '-created',
**kwargs
)
def get_dbs(cls, query=None, ancestor=None, order=None, limit=None, cursor=None, **kwargs):
return util.get_dbs(
query or cls.query(ancestor=ancestor),
limit=limit or util.param('limit', int),
cursor=cursor or util.param('cursor'),
order=order or util.param('order'),
**kwargs
)
def teams(self):
teams_dbs, more_cursor = util.retrieve_dbs(
Team.query(Team.league == self.key),
limit=util.param('limit', int),
cursor=util.param('cursor'),
order=util.param('order'),
)
return teams_dbs
def get_dbs(cls, query=None, order=None, limit=None, cursor=None, **kwgs):
return util.retrieve_dbs(
query or cls.query(),
limit=limit or util.param('limit', int),
cursor=cursor or util.param('cursor'),
order=order or util.param('order') or '-created',
**kwgs
)
def admin_pay_upgrade_service():
pay_dbs, pay_cursor = util.get_dbs(
model.Pay.query(),
limit=util.param('limit', int),
cursor=util.param('cursor'),
order=util.param('order'),
)
ndb.put_multi(pay_dbs)
return util.jsonify_model_dbs(pay_dbs, pay_cursor)
def team_topics(self):
#return Topic.query(Topic.team == self.key).fetch()
topics, more_cursor = util.retrieve_dbs(
Topic.query(Topic.team == self.key),
limit=util.param('limit', int),
cursor=util.param('cursor'),
order=util.param('order'),
)
return topics
def post(self, module_id):
module_config_obj = util.param(MODULE_CONFIG)
if not module_config_obj:
helpers.make_bad_request_exception("`module_config` parameter is expected to be found in the request")
meta = {META_KEYWORDS: util.param(META_KEYWORDS), META_DESCRIPTION: util.param(META_DESCRIPTION)}
module_config_db = store_module_config(module_config_obj, meta, module_id)
return helpers.make_response(module_config_db, model.ModuleConfig.FIELDS)
def lesson_viewport(content_type):
data = flask.json.loads(util.param("data"))
name = util.param("name")
return flask.render_template(
'shared/viewport.html',
content_type=content_type,
data=data,
name=name,
html_class='lesson-viewport',
)
def post(self):
filter_db = model.Filter(
id=u'{}-{}'.format(util.param('filter_value'),
util.param('filter_value')),
label=util.param('label'),
filter_property=util.param('filter_property'),
filter_value=util.param('filter_value'),
)
filter_db.put()
return helpers.make_response(filter_db, model.Filter.FIELDS)
def admin_cron():
account_dbs, account_cursor = model.Account.get_dbs(
order=util.param('order') or 'synced',
status=util.param('status'),
)
for account_db in account_dbs:
task.queue_account(account_db)
return 'OK'
def get_dbs(
cls, tag_name=None, related_to=None,**kwargs
):
kwargs = cls.get_col_dbs(**kwargs)
kwargs = cls.get_counter_dbs(**kwargs)
return super(TagRelation, cls).get_dbs(
tag_name=tag_name or util.param('tag_name', str),
related_to=related_to or util.param('related_to', bool),
**kwargs
)
def admin_tournament_update():
tournament_dbs, tournament_cursor = util.get_dbs(
model.Tournament.query(),
limit=util.param('limit', int) or config.DEFAULT_DB_LIMIT,
order=util.param('order'),
cursor=util.param('cursor'),
)
ndb.put_multi(tournament_dbs)
return util.jsonify_model_dbs(tournament_dbs, tournament_cursor)
def get_dbs(
cls, name=None,geo=None, creator=None, **kwargs
):
kwargs = cls.get_col_dbs(**kwargs)
kwargs = cls.get_tags_dbs(**kwargs)
return super(User, cls).get_dbs(
name=name or util.param('name', None),
geo=geo or util.param('geo', None),
creater=creater or util.param('creater', ndb.Key),
**kwargs
)
def admin_cron():
if config.PRODUCTION and 'X-Appengine-Cron' not in flask.request.headers:
flask.abort(403)
account_dbs, account_cursor = model.Account.get_dbs(
order=util.param('order') or 'modified',
status=util.param('status'),
)
for account_db in account_dbs:
task.queue_account(account_db)
return 'OK'
def get_dbs(
cls, name=None, active=None, creator=None,\
public=None, private=None, **kwargs
):
return super(Collection, cls).get_dbs(
name=name or util.param('name', None),
active=active or util.param('active', bool),
private=private or util.param('private', bool),
public=public or util.param('public', bool),
creator=creator or util.param('creator', ndb.Key),
**kwargs
)
def resource_search():
query = model.Resource.query(model.Resource.hotness > 0)
tags = util.param('tags', list)
current_filter = None
if tags:
query = query.filter(model.Resource.tags.IN(tags))
current_filter = 'tags=' + tags[0]
address_first_line = util.param('address_first_line')
if address_first_line:
query = query.filter(
model.Resource.address_first_line == address_first_line)
current_filter = 'address_first_line=' + address_first_line
address_second_line = util.param('address_second_line')
if address_second_line:
query = query.filter(
model.Resource.address_second_line == address_second_line)
current_filter = 'address_second_line=' + address_second_line
city = util.param('city')
if city:
query = query.filter(model.Resource.city == city)
current_filter = 'city=' + city
country = util.param('country')
if country:
query = query.filter(model.Resource.country == country)
current_filter = 'country=' + country
city_filter_dbs, _ = model.Filter.get_dbs(
filter_property='city',
order='-photos_count',
)
tag_filter_dbs, _ = model.Filter.get_dbs(
filter_property='tags',
order='-photos_count',
)
resource_dbs, cursors = model.Resource.get_dbs(query,
limit=20,
prev_cursor=True,
order='-hotness')
return flask.render_template(
'resource/resource_grid.html',
html_class='resource-grid',
title=u'ابحث عن صور',
resource_dbs=resource_dbs,
city_filter_dbs=city_filter_dbs,
tag_filter_dbs=tag_filter_dbs,
current_filter=current_filter,
next_url=util.generate_next_url(cursors.get('next')),
prev_url=util.generate_next_url(cursors.get('prev')),
api_url=flask.url_for('api.resource.list'),
)
def get_dbs(
cls, name=None,
tags=None, creator=None, geo=None, **kwargs
):
kwargs = cls.get_col_dbs(**kwargs)
kwargs = cls.get_tag_dbs(**kwargs)
return super(WayPoint, cls).get_dbs(
name=name or util.param('name', str),
creator=creator or util.param('creator', ndb.Key),
geo=geo or util.param('geo', str),
**kwargs
)
def admin_cron():
if config.PRODUCTION and 'X-Appengine-Cron' not in flask.request.headers:
flask.abort(403)
account_dbs, account_cursor = model.Account.get_dbs(
order=util.param('order') or 'modified',
status=util.param('status'),
)
for account_db in account_dbs:
task.queue_account(account_db)
return 'OK'
def post(self, vote_key):
"""Update a specific vote"""
vote_db = ndb.Key(urlsafe=vote_key).get()
vote = 0
if util.param('data', str) == 'upvote':
vote = ct.UP_VOTE
elif util.param('data', str) == 'downvote':
vote = ct.DOWN_VOTE
else:
flask.abort(505)
vote_db.vote(auth.current_user_key().urlsafe(), vote)
return "Success"
def post(self, vote_key):
"""Update a specific vote"""
vote_db = ndb.Key(urlsafe=vote_key).get()
vote = 0
if util.param('data', str) == 'upvote':
vote = ct.UP_VOTE
elif util.param('data', str) == 'downvote':
vote = ct.DOWN_VOTE
else:
flask.abort(505)
vote_db.vote(auth.current_user_key().urlsafe(), vote)
return "Success"
def get_dbs(
cls, name=None, private=None, \
replaced_by=None, **kwargs
):
kwargs = cls.get_col_dbs(**kwargs)
kwargs = cls.get_counter_dbs(**kwargs)
return super(Icon, cls).get_dbs(
name=name or util.param('name', None),
private=private or util.param('private', bool),
replaced_by=replaced_by or util.param('replaced_by', ndb.Key),
**kwargs
)
def tag_update(col_id=None, tag=None):
col_id = col_id or util.param('col_id')
tag = tag or util.param('tag')
if col_id and col_id!=model.Collection.top_id():
col_key = model.Collection.id_to_key(col_id)
col_db = col_key.get()
else:
col_key = model.Collection.top_key()
col_db = None
if tag:
tag_db = model.Tag.tag_to_key(tag,col_key).get()
else:
tag_db = None
form = TagUpdateForm(obj=tag_db)
if form.validate_on_submit():
if form.icon.data:
fs = flask.request.files.getlist("icon")
if fs:
icon = data=fs[0].read()
else:
icon=None
else:
icon=None
if not form.icon_id.data:
#icon_id = ndb.Key(urlsafe=form.icon_key.data)
icon_id = None
else:
icon_id = form.icon_id.data
model.Tag.add(form.name.data,collection=col_key,icon_id=icon_id,
icon_data=icon,color=form.color.data,
force_new_icon=form.force_icon.data,
auto_incr=form.incr_counter.data)
# get user key
return flask.redirect(flask.url_for(
'tag_list', col_id=col_id, order='-modified'
))
return flask.render_template(
'tag/tag_update.html',
title= "Update Tag" if tag_db else "Add New Tag" ,#col_db or 'Add New Tag',
html_class='tag-update',
form=form,
collection=col_key,
col_db=col_db,
tag_db=tag_db,
api_url=None#flask.url_for('api.user', col_key=col_db.key.urlsafe()) if col_db.key else ''
)
def delete(self):
story_keys = util.param('story_keys', list)
restore = util.param('restore', bool)
if not story_keys:
helpers.make_not_found_exception('Story(s) %s assigned in the parameter [story_keys]'
' not found' % story_keys)
story_db_keys = [ndb.Key(urlsafe=k) for k in story_keys]
api_resource_base.set_obj_dbs_deleted(story_db_keys, restore)
return flask.jsonify({
'result': story_keys,
'status': 'success',
'now': datetime.utcnow().isoformat()
})
def update_user_tutor():
event_dbs, event_cursor = util.get_dbs(
model.Event.query(),
limit=util.param("limit", int) or config.MAX_DB_LIMIT,
order=util.param("order"),
cursor=util.param("cursor"),
)
for event_db in event_dbs:
event_db.accuracy = "day"
ndb.put_multi(event_dbs)
return util.jsonify_model_dbs(event_dbs, event_cursor)
def user_list():
user_dbs, user_cursor = model.User.get_dbs(email=util.param('email'))
permissions = list(UserUpdateForm._permission_choices)
permissions += util.param('permissions', list) or []
return flask.render_template(
'user/user_list.html',
html_class='user-list',
title='User List',
user_dbs=user_dbs,
next_url=util.generate_next_url(user_cursor),
api_url=flask.url_for('api.user.list'),
permissions=sorted(set(permissions)),
)
def contact_list():
contact_dbs, more_cursor = util.retrieve_dbs(model.Contact.query(),
limit=util.param('limit',int),
cursor=util.param('cursor'),
order=util.param('order') or 'name',
)
return flask.render_template(
'contact_list.html',
html_class='contact-list',
title='Contact List',
contact_dbs=contact_dbs,
more_url = util.generate_more_url(more_cursor),
)
def user_list():
user_dbs, user_cursor = model.User.get_dbs(email=util.param('email'))
permissions = list(UserUpdateForm._permission_choices)
permissions += util.param('permissions', list) or []
return flask.render_template(
'user/user_list.html',
html_class='user-list',
title='User List',
user_dbs=user_dbs,
next_url=util.generate_next_url(user_cursor),
api_url=flask.url_for('api.user.list'),
permissions=sorted(set(permissions)),
)
def post(self, vote_key):
"""Update a specific vote"""
vote_db = ndb.Key(urlsafe=vote_key).get()
upvote = 0
downvote = 0
if util.param('data', str) == 'upvote':
upvote = 1
elif util.param('data', str) == 'downvote':
downvote = 1
else:
flask.abort(505)
if auth.current_user_key() and (upvote or downvote):
vote_db.vote(auth.current_user_key().urlsafe(), upvote, downvote)
return "Success"
def contact_list():
contact_dbs, more_cursor = util.retrieve_dbs(
model.Contact.query(),
limit=util.param('limit', int),
cursor=util.param('cursor'),
order=util.param('order') or 'name',
)
return flask.render_template(
'contact_list.html',
html_class='contact-list',
title='Contact List',
contact_dbs=contact_dbs,
more_url=util.generate_more_url(more_cursor),
)
def user_list():
user_dbs, more_cursor = util.retrieve_dbs(
model.User.query(),
limit=util.param('limit', int),
cursor=util.param('cursor'),
order=util.param('order') or '-created',
name=util.param('name'),
admin=util.param('admin', bool),
active=util.param('active', bool),
permissions=util.param('permissions', list),
)
if flask.request.path.startswith('/_s/'):
return util.jsonify_model_dbs(user_dbs, more_cursor)
permissions = list(UserUpdateForm._permission_choices)
permissions += util.param('permissions', list) or []
return flask.render_template(
'user/user_list.html',
html_class='user-list',
title='User List',
user_dbs=user_dbs,
more_url=util.generate_more_url(more_cursor),
has_json=True,
permissions=sorted(set(permissions)),
)
def user_list():
user_dbs, more_cursor = util.retrieve_dbs(
model.User.query(),
limit=util.param('limit', int),
cursor=util.param('cursor'),
order=util.param('order') or '-created',
name=util.param('name'),
admin=util.param('admin', bool),
active=util.param('active', bool),
permissions=util.param('permissions', list),
)
if flask.request.path.startswith('/_s/'):
return util.jsonify_model_dbs(user_dbs, more_cursor)
permissions = list(UserUpdateForm._permission_choices)
permissions += util.param('permissions', list) or []
return flask.render_template(
'user/user_list.html',
html_class='user-list',
title='User List',
user_dbs=user_dbs,
more_url=util.generate_more_url(more_cursor),
has_json=True,
permissions=sorted(set(permissions)),
)
def verse_list():
verse_dbs, more_cursor = util.retrieve_dbs(
model.Verse.query(),# @UndefinedVariable
limit=util.param('limit', 600),
cursor=util.param('cursor'),
order=util.param('order'),
)
return flask.render_template(
'verse_list.html',
html_class='verse-list',
title='Verse List',
verse_dbs=verse_dbs,
more_url=util.generate_more_url(more_cursor),
)
def verse_list():
verse_dbs, more_cursor = util.retrieve_dbs(
model.Verse.query(), # @UndefinedVariable
limit=util.param('limit', 600),
cursor=util.param('cursor'),
order=util.param('order'),
)
return flask.render_template(
'verse_list.html',
html_class='verse-list',
title='Verse List',
verse_dbs=verse_dbs,
more_url=util.generate_more_url(more_cursor),
)
def get_dbs(
cls, name=None, color=None, approved=None,
**kwargs
):
kwargs = cls.get_col_dbs(**kwargs)
kwargs = cls.get_counter_dbs(**kwargs)
name=name or util.param('name', str)
name=cls.validate_tag(name)
return super(Tag, cls).get_dbs(
name=name,
color=color or util.param('color', str),
approved=approved or util.param('approved', bool),
**kwargs
)
def category_json():
key_id = param('id')
if not key_id:
raise ApiException('Invalid request: category "id" not found.')
category = Category.retrieve_by_id(key_id)
if not category:
raise ApiException(
'Invalid request: Category with "id" == %s not found' % key_id)
id_1c = param('id_1c')
if id_1c is not None:
category._PROPERTIES = category._PROPERTIES.union(
['products_by_id_1c'])
return jsonify_model_db(category)
return jsonify_model_db(category)
def index(query, page):
view_type = util.param('product_view_type', int)
session_view_type = session.get('product_view_type', None)
if session_view_type is None or\
session_view_type not in PRODUCT_VIEW_TYPES.itervalues():
if view_type in PRODUCT_VIEW_TYPES.itervalues():
session['product_view_type'] = view_type
else:
session['product_view_type'] = PRODUCT_VIEW_TYPES['tile']
else:
if view_type in PRODUCT_VIEW_TYPES.itervalues():
session['product_view_type'] = view_type
query = query.strip().lower()
if not query:
return render_template('search/index.html',
title=u"Поиск по сайту",
query=query,
categories=[],
products=[])
products = search_products(query)
if products:
products = search_products_paginator(products, page)
return render_template('search/index.html',
title=u'Поиск по сайту',
query=query,
categories=search_categories(query),
products=products)
def post(self):
username = util.param('username') or util.param('email')
password = util.param('password')
if not username or not password:
return flask.abort(400)
if username.find('@') > 0:
user_db = model.User.get_by('email', username.lower())
else:
user_db = model.User.get_by('username', username.lower())
if user_db and user_db.password_hash == util.password_hash(
user_db, password):
auth.signin_user_db(user_db)
return helpers.make_response(user_db, model.User.FIELDS)
return flask.abort(401)
def category(key_id, page):
view_type = util.param('product_view_type', int)
session_view_type = flask.session.get('product_view_type', None)
if session_view_type is None or session_view_type not in PRODUCT_VIEW_TYPES.itervalues(
):
if view_type in PRODUCT_VIEW_TYPES.itervalues():
flask.session['product_view_type'] = view_type
else:
flask.session['product_view_type'] = PRODUCT_VIEW_TYPES['tile']
else:
if view_type in PRODUCT_VIEW_TYPES.itervalues():
flask.session['product_view_type'] = view_type
category_obj = Category.retrieve_by_id(key_id)
if not category_obj:
return flask.redirect(flask.url_for('pages.index'))
products = Product\
.query(Product.category == category_obj.name)\
.order(-Product.leftovers_on_way)\
.order(-Product.leftovers)
products = get_paginator(products, page)
return flask.render_template('pages/category.html',
title=u'{} "{}"'.format(
u'Категория', category_obj.name),
category=category_obj,
products=products,
key_id=key_id)
def admin_stats(duration='day'):
if duration not in ['day', 'week', 'month', 'year']:
flask.abort(404)
stats_dbs, stats_cursor = model.Stats.get_dbs(
duration=duration,
order=util.param('order') or '-timestamp',
limit=util.param('limit', int) or 60 if duration == 'day' else -1,
)
return flask.render_template(
'admin/stats.html',
html_class='admin-stats admin-stats-%s' % duration,
title='Stats - %s' % duration.title(),
stats_dbs=stats_dbs,
duration=duration,
)
def user_list():
user_dbs, user_cursor = model.User.get_dbs(email=util.param('email'))
if flask.request.path.startswith('/_s/'):
return util.jsonify_model_dbs(user_dbs, user_cursor)
permissions = list(UserUpdateForm._permission_choices)
permissions += util.param('permissions', list) or []
return flask.render_template(
'user/user_list.html',
html_class='user-list',
title='User List',
user_dbs=user_dbs,
next_url=util.generate_next_url(user_cursor),
has_json=True,
permissions=sorted(set(permissions)),
)
def user_delete_service():
user_keys = util.param('user_keys', list)
user_db_keys = [ndb.Key(urlsafe=k) for k in user_keys]
delete_user_dbs(user_db_keys)
return flask.jsonify({
'result': user_keys,
'status': 'success',
})
def products_json():
is_available = param('available', bool)
if is_available is not None:
if is_available:
products_q = Product.query(Product.is_available == True)
else:
products_q = Product.query(Product.is_available != True)
else:
products_q = Product.query()
is_1c = param('id_1c')
if is_1c is not None:
return jsonify_success([
key.id_1c for key in products_q.fetch(projection=[Product.id_1c])
])
return jsonify_success(
[key.id() for key in products_q.fetch(keys_only=True)])
def get(self):
user_keys = util.param('user_keys', list)
if user_keys:
user_db_keys = [ndb.Key(urlsafe=k) for k in user_keys]
user_dbs = ndb.get_multi(user_db_keys)
return helpers.make_response(user_dbs, model.User.FIELDS)
user_dbs, cursors = model.User.get_dbs(prev_cursor=True)
return helpers.make_response(user_dbs, model.User.FIELDS, cursors)
def get(self):
repo_keys = util.param('repo_keys', list)
if repo_keys:
repo_db_keys = [ndb.Key(urlsafe=k) for k in repo_keys]
repo_dbs = ndb.get_multi(repo_db_keys)
return helpers.make_response(repo_dbs, model.repo.FIELDS)
repo_dbs, repo_cursor = model.Repo.get_dbs()
return helpers.make_response(repo_dbs, model.Repo.FIELDS, repo_cursor)
