def livros(_write_tmpl, **params):
index = params["pag"] if params.has_key("pag") else ""
_type = params["type"] if params.has_key("type") else "next"
cursor = Cursor(urlsafe=index)
query = Livro.query()
has_previous = False
if _type == "previous":
q_backward = query.order(-Livro.titulo)
livros, previous, has_previous = q_backward.fetch_page(5, start_cursor = cursor.reversed())
has_next = True
next = cursor.reversed()
for l in livros:
l.id = l.key.id()
livros = reversed(livros)
else:
q_forward = query.order(Livro.titulo)
livros, next, has_next = q_forward.fetch_page(5, start_cursor = cursor)
if params.has_key("pag") and params["pag"] != '':
has_previous = True
previous = cursor
for l in livros:
l.id = l.key.id()
var = {"livros":livros,
"has_next":has_next,
"has_previous":has_previous,
"previous_cursor":previous,
"next_cursor":next}
_write_tmpl('templates/panel/livros.html', var)
def show_books():
fwd_query = model.Book.query().order(model.Book.title, model.Book.key)
rev_query = model.Book.query().order(-model.Book.title)
cursor = Cursor(urlsafe=request.values.get('cursor'))
direction = request.values.get('dir') or 'next'
fetch_args = {}
query = fwd_query
fetch_args['start_cursor'] = cursor
if direction == 'prev':
fetch_args['start_cursor'] = cursor.reversed()
query = rev_query
all_books, next_cursor, more = query.fetch_page(10, **fetch_args)
all_books.reverse()
return render_template(
'list_books.html',
list_heading="All Books",
books=all_books,
n_cursor=cursor.reversed().urlsafe(),
p_cursor=next_cursor.urlsafe(),
)
else:
all_books, next_cursor, more = query.fetch_page(10, **fetch_args)
return render_template(
'list_books.html',
list_heading="All Books",
books=all_books,
p_cursor=cursor.reversed().urlsafe(),
n_cursor=next_cursor.urlsafe(),
)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = models.BlogPost.query(
ndb.OR(models.BlogPost.title == q.lower(),
models.BlogPost.author == q.lower(),
models.BlogPost.category.IN(q.lower().split(','))))
count = qry.count()
blogs = qry
else:
qry = models.BlogPost.query()
count = qry.count()
PAGE_SIZE = 50
if forward:
blogs, next_cursor, more = qry.order(
-models.BlogPost.updated).fetch_page(PAGE_SIZE,
start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
blogs, next_cursor, more = qry.order(
models.BlogPost.updated).fetch_page(PAGE_SIZE,
start_cursor=cursor)
blogs = list(reversed(blogs))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-blog', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('title', 'Title'), ('author', 'Author'),
('created', 'Created'), ('updated', 'Updated'),
('category', 'Categories')],
"blogs":
blogs,
"count":
count
}
params['nickname'] = g_users.get_current_user().email().lower()
return self.render_template('blog/admin_blog.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = LogEmail.query(
ndb.OR(LogEmail.to == q.lower(), LogEmail.sender == q.lower(),
LogEmail.subject == q.lower()))
else:
qry = LogEmail.query()
PAGE_SIZE = 50
if forward:
emails, next_cursor, more = qry.order(LogEmail.key).fetch_page(
PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
emails, next_cursor, more = qry.order(-LogEmail.key).fetch_page(
PAGE_SIZE, start_cursor=cursor)
emails = list(reversed(emails))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-logs-emails', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [
('when', 'When'),
('to', 'To'),
('subject', 'Subject'),
('sender', 'Sender'),
# ('body', 'Body')
],
"emails":
emails,
"count":
qry.count()
}
return self.render_template('admin_logs_emails.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = self.user_model.query(
ndb.OR(self.user_model.last_name == q.lower(),
self.user_model.email == q.lower(),
self.user_model.username == q.lower()))
else:
qry = self.user_model.query()
PAGE_SIZE = 50
if forward:
users, next_cursor, more = qry.order(
self.user_model.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
users, next_cursor, more = qry.order(
-self.user_model.key).fetch_page(PAGE_SIZE,
start_cursor=cursor)
users = list(reversed(users))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-users-list', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('username', 'Username'), ('name', 'Name'),
('last_name', 'Last Name'), ('email', 'Email'),
('country', 'Country'), ('tz', 'TimeZone')],
"users":
users,
"count":
qry.count()
}
return self.render_template('admin_users_list.html', **params)
def get(self, *args, **kwargs):
self.model_class = kwargs["_class"]
self.form_class = kwargs["_form_class"]
p = self.request.get("p")
q = self.request.get("q")
c = self.request.get("c")
forward = True if p not in ["prev"] else False
cursor = Cursor(urlsafe=c)
from google.appengine.ext.ndb.query import Node
if q:
nodes = []
for search in self.form_class.search_list:
nodes.append(FilterNode(search, "=", q))
qry = self.model_class.query(ndb.OR(*nodes))
else:
qry = self.model_class.query()
PAGE_SIZE = 5
if forward:
users, next_cursor, more = qry.order(self.model_class.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
users, next_cursor, more = qry.order(-self.model_class.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
users = list(reversed(users))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params["q"] = q
if p in ["prev"]:
params["p"] = p
if cursor:
params["c"] = cursor.urlsafe()
return self.uri_for("%s-list" % self.model_class.__name__.lower(), **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"class_name": self.model_class.__name__,
"list_columns": self.form_class.list_columns,
"users": users,
"count": qry.count(),
"add_uri": self.uri_for("%s-add" % self.model_class.__name__.lower()),
}
logger.warn(params)
return self.render_template("admin/list.html", **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
user_key = ndb.Key(User, long(q.lower()))
qry = LogVisit.query(
ndb.OR(LogVisit.user == user_key,
LogVisit.timestamp == q.lower(),
LogVisit.uastring == q.lower(),
LogVisit.ip == q.lower()))
else:
qry = LogVisit.query()
PAGE_SIZE = 50
if forward:
visits, next_cursor, more = qry.order(LogVisit.key).fetch_page(
PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
visits, next_cursor, more = qry.order(-LogVisit.key).fetch_page(
PAGE_SIZE, start_cursor=cursor)
visits = list(reversed(visits))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-visitlogs-list', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('timestamp', 'Timestamp'), ('ip', 'IP'),
('uastring', 'uastring')],
"visits":
visits,
"count":
qry.count()
}
return self.render_template('admin_visitlogs_list.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = models.BlogPost.query(ndb.OR(models.BlogPost.title == q.lower(),
models.BlogPost.author == q.lower(),
models.BlogPost.category.IN(q.lower().split(','))))
count = qry.count()
blogs = qry
else:
qry = models.BlogPost.query()
count = qry.count()
PAGE_SIZE = 50
if forward:
blogs, next_cursor, more = qry.order(-models.BlogPost.updated).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
blogs, next_cursor, more = qry.order(models.BlogPost.updated).fetch_page(PAGE_SIZE, start_cursor=cursor)
blogs = list(reversed(blogs))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-blog', **params)
self.view.pager_url = pager_url
self.view.q = q
if self.app.config.get('app_lang') == 'es':
list_columns = [('title', u'Título'), ('author', 'Autor'), ('created', u'Fecha de creación'), ('updated', u'Fecha de actualización'), ('category', u'Categorías')]
else:
list_columns = [('title', u'Title'), ('author', 'Author'), ('created', u'Created'), ('updated', u'Updated'), ('category', u'Categories')]
params = {
"list_columns": list_columns,
"blogs": blogs,
"count": count
}
params['nickname'] = g_users.get_current_user().email().lower()
return self.render_template('%s/blog/admin_blog.html' % self.app.config.get('app_lang'), **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = models.User.query(ndb.OR(models.User.last_name == q,
models.User.email == q,
models.User.username == q))
else:
qry = models.User.query()
PAGE_SIZE = 5
if forward:
users, next_cursor, more = qry.order(models.User.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
users, next_cursor, more = qry.order(-models.User.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
users = list(reversed(users))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('user-list', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('username', 'Username'),
('last_name', 'Last Name'),
('email', 'E-Mail'),
('country', 'Country')],
"users" : users,
"count" : qry.count()
}
# FIXME: admin_user should probably go into BaseHandler
params['admin_user'] = googleusers.is_current_user_admin()
return self.render_template('admin/users.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
user_key = ndb.Key('User', long(self.user_id))
if q:
qry = Bom.query(
Bom.owners == user_key,
ndb.OR(Bom.public_id == q, Bom.name == q, Bom.tag_name == q))
else:
qry = Bom.query(Bom.owners == user_key)
PAGE_SIZE = 5
if forward:
boms, next_cursor, more = qry.order(Bom.key).fetch_page(
PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
boms, next_cursor, more = qry.order(-Bom.key).fetch_page(
PAGE_SIZE, start_cursor=cursor)
boms = list(reversed(boms))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('boms', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('name', 'BOM Name'), ('public_id', 'Public ID'),
('public', 'public'),
('change_time', 'Last Updated')],
"boms":
boms,
"count":
qry.count()
}
return self.render_template('boms.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = Bom.query(ndb.OR(Bom.public_id == q,
Bom.name == q,
Bom.tag_name == q))
else:
qry = Bom.query()
PAGE_SIZE = 5
if forward:
boms, next_cursor, more = qry.order(Bom.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
boms, next_cursor, more = qry.order(-Bom.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
boms = list(reversed(boms))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('boms-admin', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('public_id', 'Public ID'),
('name', 'BOM Name'),
('tag_name', 'Tag Name'),
('public', 'public')],
"boms" : boms,
"count" : qry.count(),
}
# FIXME: admin_user should probably go into BaseHandler
params['admin_user'] = googleusers.is_current_user_admin()
return self.render_template('admin/boms.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = LogEmail.query(ndb.OR(LogEmail.to == q.lower(),
LogEmail.sender == q.lower(),
LogEmail.subject == q.lower()))
else:
qry = LogEmail.query()
PAGE_SIZE = 50
if forward:
emails, next_cursor, more = qry.order(LogEmail.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
emails, next_cursor, more = qry.order(-LogEmail.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
emails = list(reversed(emails))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-logs-emails', **params)
self.view.pager_url = pager_url
self.view.q = q
if self.app.config.get('app_lang') == 'es':
list_columns = [('when', 'Fecha'),('to', 'Destinatario'),('subject', 'Asunto'),('sender', 'Remitente')]
else:
list_columns = [('when', 'Date'),('to', 'Recipient'),('subject', 'Subject'),('sender', 'Sender')]
params = {
"list_columns": list_columns,
"emails": emails,
"count": qry.count()
}
params['nickname'] = g_users.get_current_user().email().lower()
return self.render_template('%s/emails/admin_logs_emails.html' % self.app.config.get('app_lang'), **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = models.Seller.query(ndb.OR(models.Seller.n == q,
models.Seller.cn == q))
else:
qry = models.Seller.query()
PAGE_SIZE = 5
if forward:
sellers, next_cursor, more = qry.order(models.User.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
sellers, next_cursor, more = qry.order(-models.Seller.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
sellers = list(reversed(users))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('user-list', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('n', 'Seller'),
('dom', 'Domain'),
('cn', 'Contact Name'),
('pn', 'Phone Number'),
('cat', 'Category'),
('active', 'Active'),
('auth', 'Authenticated')],
"sellers" : sellers,
'pageTitle': 'Sellers List',
"count" : qry.count()
}
return self.render_template('admin/list.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = models.BlogPost.query(ndb.OR(models.BlogPost.title == q.lower(),
models.BlogPost.author == q.lower(),
models.BlogPost.category.IN(q.lower().split(','))))
count = qry.count()
blogs = qry
else:
qry = models.BlogPost.query()
count = qry.count()
PAGE_SIZE = 50
if forward:
blogs, next_cursor, more = qry.order(-models.BlogPost.updated).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
blogs, next_cursor, more = qry.order(models.BlogPost.updated).fetch_page(PAGE_SIZE, start_cursor=cursor)
blogs = list(reversed(blogs))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-blog', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('title', 'Title'),
('author', 'Author'),
('created', 'Created'),
('updated', 'Updated'),
('category', 'Categories')],
"blogs": blogs,
"count": count
}
return self.render_template('admin_blog.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
user_key = ndb.Key(User,long(q.lower()))
qry = LogVisit.query(ndb.OR( LogVisit.user == user_key,
LogVisit.timestamp == q.lower(),
LogVisit.uastring == q.lower(),
LogVisit.ip == q.lower()))
else:
qry = LogVisit.query()
PAGE_SIZE = 50
if forward:
visits, next_cursor, more = qry.order(LogVisit.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
visits, next_cursor, more = qry.order(-LogVisit.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
visits = list(reversed(visits))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-logs-visits', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('timestamp', 'Timestamp'),
('ip', 'IP'),
('uastring', 'uastring')
],
"visits": visits,
"count": qry.count()
}
return self.render_template('admin_logs_visits.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = self.user_model.query(ndb.OR(self.user_model.last_name == q.lower(),
self.user_model.email == q.lower(),
self.user_model.username == q.lower()))
else:
qry = self.user_model.query()
PAGE_SIZE = 50
if forward:
users, next_cursor, more = qry.order(self.user_model.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
users, next_cursor, more = qry.order(-self.user_model.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
users = list(reversed(users))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-users-list', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('username', 'Username'),
('name', 'Name'),
('last_name', 'Last Name'),
('email', 'Email'),
('country', 'Country'),
('tz', 'TimeZone')],
"users": users,
"count": qry.count()
}
return self.render_template('admin_users_list.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = LogEmail.query(ndb.OR(LogEmail.to == q.lower(),
LogEmail.sender == q.lower(),
LogEmail.subject == q.lower()))
else:
qry = LogEmail.query()
PAGE_SIZE = 50
if forward:
emails, next_cursor, more = qry.order(LogEmail.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
emails, next_cursor, more = qry.order(-LogEmail.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
emails = list(reversed(emails))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-logs-emails', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('when', 'When'),
('to', 'To'),
('subject', 'Subject'),
('sender', 'Sender'),
# ('body', 'Body')
],
"emails": emails,
"count": qry.count()
}
return self.render_template('admin_logs_emails.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
user_key = ndb.Key('User', long(self.user_id))
if q:
qry = Bom.query(Bom.owners == user_key,
ndb.OR(Bom.public_id == q,
Bom.name == q,
Bom.tag_name == q))
else:
qry = Bom.query(Bom.owners == user_key)
PAGE_SIZE = 5
if forward:
boms, next_cursor, more = qry.order(Bom.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
boms, next_cursor, more = qry.order(-Bom.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
boms = list(reversed(boms))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('boms', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('name', 'BOM Name'),
('public_id', 'Public ID'),
('public', 'public'),
('change_time', 'Last Updated')],
"boms" : boms,
"count" : qry.count()
}
return self.render_template('boms.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = Group.query()
else:
qry = Group.query()
PAGE_SIZE = 50
if forward:
groups, next_cursor, more = qry.order(self.user_model.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
groups, next_cursor, more = qry.order(-self.user_model.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
groups = list(reversed(groups))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-groups-list', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('group', 'Group'),
('can_view', 'Can View'),
('can_edit', 'Can Edit'),
('can_administer', 'Can Adminster'),
('can_upload', 'Can Upload'),
],
"groups": groups,
"count": qry.count()
}
return self.render_template('admin_groups_list.html', **params)
def get(self):
f_cursor_param = self.request.get('f_cursor')
b_cursor_param = self.request.get('b_cursor')
template_values = {}
if b_cursor_param:
words_query = Word.query(ancestor=create_dictionary_key()).order(Word.date)
b_cursor = Cursor(urlsafe=self.request.get('b_cursor'))
template_values['f_cursor'] = b_cursor.urlsafe()
rev_curs = b_cursor.reversed()
words, next_cursor, more = words_query.fetch_page(WORDS_PER_PAGE, start_cursor=rev_curs)
words.reverse()
if more and next_cursor:
template_values['b_cursor'] = next_cursor.reversed().urlsafe()
else:
words_query = Word.query(ancestor=create_dictionary_key()).order(-Word.date)
f_cursor = Cursor(urlsafe=self.request.get('f_cursor'))
template_values['b_cursor'] = f_cursor.urlsafe()
words, next_cursor, more = words_query.fetch_page(WORDS_PER_PAGE, start_cursor=f_cursor)
if more and next_cursor:
template_values['f_cursor'] = next_cursor.urlsafe()
wordDTOs = []
for word in words:
wordDTOs.append(WordDTO(word.word, word.description, word.example))
template_values['words'] = wordDTOs
self.response.out.write(template.render(get_template_path('view_words.html'), template_values))
def projects(bookmark_cursor=None):
cursor = None
if bookmark_cursor:
cursor = Cursor(urlsafe=bookmark_cursor)
query = Project.query()
next_query = query.order(-Project.updated_at)
previous_query = query.order(Project.updated_at)
entities, next_cursor, has_next = next_query.fetch_page(
PER_PAGE, start_cursor=cursor)
if next_cursor:
next_cursor = next_cursor.urlsafe()
has_previous = False
previous_cursor = None
if cursor:
previous_cursor = cursor.reversed()
previous_entities, previous_cursor, has_previous = previous_query.fetch_page(
PER_PAGE, start_cursor=previous_cursor)
if previous_cursor:
has_previous = True
previous_cursor = previous_cursor.urlsafe()
return {
'entities': entities,
'nextCursor': next_cursor,
'hasNext': has_next,
'previousCursor': previous_cursor,
'hasPrevious': has_previous
}
def get_movies(self, request):
query = movie.Movie.query()
if request.order == GetMoviesRequest.Order.TITLE:
query = query.order(movie.Movie.title)
if request.direction == request.direction.NEXT:
if request.next_cursor: # usual_case
cursor = Cursor(urlsafe=request.next_cursor)
current_cursor = request.next_cursor
else: # No Cursors. First batch
cursor = Cursor()
current_cursor = cursor.urlsafe()
movies, next_cursor, more = query.fetch_page(
request.how_many_on_page, start_cursor=cursor)
if next_cursor:
next_cursor = next_cursor.urlsafe()
elif request.direction == request.direction.PREVIOUS:
if not (
request.current_cursor and request.next_cursor
): # We are at first batch cursor- there is no data to get in this direction.
raise NoPageLeftInThatDirection(
"Cannot get more in that direction.")
cursor = Cursor(urlsafe=request.current_cursor)
cursor.reversed()
movies, next_cursor, more = query.fetch_page(
request.how_many_on_page, start_cursor=cursor)
current_cursor = next_cursor.reversed().urlsafe()
next_cursor = cursor.reversed().urlsafe()
else:
raise UnknownDirection(
"Direction %s is unknown. % request.direction")
map_to_movie = lambda item: Movie(
title=item.title, ID=item.key.id(), description=item.description)
movies = map(map_to_movie, movies)
return GetMoviesRespond(movies=movies,
next_cursor=next_cursor,
current_cursor=current_cursor,
more_to_get=more)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
qry = models.Shapers.query()
count = qry.count()
PAGE_SIZE = 50
if forward:
shapers, next_cursor, more = qry.order(-models.Shapers.created).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
shapers, next_cursor, more = qry.order(models.Shapers.created).fetch_page(PAGE_SIZE, start_cursor=cursor)
shapers = list(reversed(shapers))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-blog', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('name', 'Name'),
('created', 'Created'),
('key', 'Key'),
('image', 'Image URL')],
"shapers": shapers,
"count": count
}
return self.render_template('admin_shapers.html', **params)
def GetPagedResults(query,
order_properties,
cursor=None,
direction=NEXT,
page_size=PAGE_SIZE):
"""Paging the query results with page_size.
Args:
query(ndb.Query): The ndb query to query entities.
order_properties: A list of tuples containing class attribute of entity
class to order the entities and ordering of the field.
cursor (Cursor): The cursor provides a cursor in the current query
results, allowing you to retrieve the next set based on the offset.
direction (str): Either previous or next.
page_size (int): Number of entities to show per page.
Returns:
A tuple of (entities, top_cursor, next_cursor).
entities (list): List of entities to be displayed at the current page.
top_cursor (str): The urlsafe encoding of the cursor, which is at the
top position of entities of the current page.
bottom_cursor (str): The urlsafe encoding of the cursor, which is at the
bottom position of entities of the current page.
"""
cursor = Cursor(urlsafe=cursor) if cursor else None
if direction.lower() == PREVIOUS:
for order_property, forward_order in order_properties:
if forward_order == DESC:
# Forward order is desc meaning backward order should be asc.
query = query.order(order_property)
if forward_order == ASC:
# Forward order is asc meaning backward order should be desc.
query = query.order(-order_property)
entities, next_cursor, more = query.fetch_page(
page_size, start_cursor=cursor.reversed())
entities.reverse()
else:
for order_property, forward_order in order_properties:
if forward_order == DESC:
query = query.order(-order_property)
if forward_order == ASC:
query = query.order(order_property)
entities, next_cursor, more = query.fetch_page(page_size,
start_cursor=cursor)
next_cursor = next_cursor.urlsafe() if next_cursor else ''
used_cursor = cursor.urlsafe() if cursor else ''
if direction.lower() == PREVIOUS:
top_cursor = next_cursor if more else ''
bottom_cursor = used_cursor
else:
top_cursor = used_cursor
bottom_cursor = next_cursor if more else ''
return entities, top_cursor, bottom_cursor
def __init__(self, model_cls, limit, order, cursor_str="", query=None):
cursor = Cursor(urlsafe=cursor_str) if cursor_str else Cursor()
rcursor = cursor.reversed()
cls_order = getattr(model_cls, order)
if query == None: query = model_cls.query()
q_forward = query.order(cls_order)
q_reverse = query.order(-cls_order)
self._items, self._next_cursor, self._more = q_forward.fetch_page(limit, start_cursor=cursor)
unused_itemss, self._prev_cursor, unused_prev_more = q_reverse.fetch_page(limit, start_cursor=rcursor)
self._cursor = cursor
def render_interface(self, **kwds):
default_limit = self.option("default_limit")
default_order = self.option("default_order")
model_cls = self.option("model_cls")
props = self.option("props")
cursor_str = self.request.get("cursor")
cursor = Cursor(urlsafe=cursor_str) if cursor_str else Cursor()
try:
limit = int(self.request.get("limit", default_value=default_limit))
except ValueError:
limit = default_limit
order = self.request.get("order", default_value=default_order)
if not (order in props):
order = default_order
cls_order = getattr(model_cls, order)
rcursor = cursor.reversed()
q_forward = model_cls.query().order(cls_order)
q_reverse = model_cls.query().order(-cls_order)
models, next_cursor, more = q_forward.fetch_page(limit, start_cursor=cursor)
unused_models, prev_cursor, unused_prev_more = q_reverse.fetch_page(limit, start_cursor=rcursor)
def get_current_url(cursor, **kwds):
params = "?"
params += "&".join(["%s=%s" % (k, v)
for k, v in {
"cursor": cursor.urlsafe(),
"limit": str(limit),
}.iteritems()
])
return self.request.path + params
def table_model_attr(model, attr):
if attr[-2:] == "()":
return getattr(model, attr[:-2])()
else: return getattr(model, attr)
values = {
"table_model_attr": table_model_attr,
"models": models,
"props": props,
"toolbox": self.option("toolbox"),
"links": self.option("links"),
"operations": self.option("operations"),
"has_next": lambda: more,
"has_prev": lambda: (cursor != Cursor()) and (prev_cursor != None),
"next_url": get_current_url(cursor=next_cursor) if next_cursor else "",
"prev_url": get_current_url(cursor=prev_cursor.reversed()) if prev_cursor and cursor else "",
}
return self.render("admin_table_interface", values)
def getPage(query, req, qty=10):
"""Gets items for constructing a page, and the next cursor object for
getting the next page."""
qolder = query.order(-models.Entry.date)
qnewer = query.order(models.Entry.date)
curs = Cursor(urlsafe=req.args.get('cursor'))
entries, next_curs, more = qolder.fetch_page(qty, start_cursor=curs)
_, prev_curs, less = qnewer.fetch_page(qty, start_cursor=curs.reversed())
buttons = (
prev_curs.urlsafe() if less and prev_curs else None,
next_curs.urlsafe() if more and next_curs else None
)
return (entries, buttons)
def GetPagedResults(query,
order_property,
cursor=None,
direction=_NEXT,
page_size=PAGE_SIZE):
"""Paging the query results with page_size.
Args:
query(ndb.Query): The ndb query to query entities.
order_property (DateTimeProperty of ndb.Model): A class attribute of
entity class to order the entities.
cursor (Cursor): The cursor provides a cursor in the current query
results, allowing you to retrieve the next set based on the offset.
direction (str): Either previous or next.
page_size (int): Number of entities to show per page.
Returns:
A tuple of (entities, top_cursor, next_cursor).
entities (list): List of entities to be displayed at the current page.
top_cursor (str): The urlsafe encoding of the cursor, which is at the
top position of entities of the current page.
bottom_cursor (str): The urlsafe encoding of the cursor, which is at the
bottom position of entities of the current page.
"""
cursor = Cursor(urlsafe=cursor) if cursor else None
if direction.lower() == _PREVIOUS:
query = query.order(order_property)
entities, next_cursor, more = query.fetch_page(
page_size, start_cursor=cursor.reversed())
entities.reverse()
else:
query = query.order(-order_property)
entities, next_cursor, more = query.fetch_page(page_size,
start_cursor=cursor)
next_cursor = next_cursor.urlsafe() if next_cursor else ''
used_cursor = cursor.urlsafe() if cursor else ''
if direction.lower() == _PREVIOUS:
top_cursor = next_cursor if more else ''
bottom_cursor = used_cursor
else:
top_cursor = used_cursor
bottom_cursor = next_cursor if more else ''
return entities, top_cursor, bottom_cursor
def get(self, uid=None, date=None):
if not users.is_current_user_admin():
raise NotAuthorisedException('Only admins can use this service')
context = {'handler':self}
curs = Cursor(urlsafe=self.request.get('cursor'))
query = EventLog.query()
if uid is not None:
query = query.filter(EventLog.uid==uid)
#context["title_link"]=self.uri_for('logging')
context['uid'] = uid
try:
context['latlong'] = self.request.headers['X-AppEngine-CityLatLong'].split(',')
except KeyError:
pass
if date is not None:
date = from_isodatetime(date)
if date is not None:
context["title_link"]=self.uri_for('logging')
context["date"] = date
query = query.filter(EventLog.date==date)
logs, next_curs, next = query.order(EventLog.date).fetch_page(20, start_cursor=curs)
context["logs"] = logs
if uid and logs:
context['info']={}
for log in logs:
if log.loc.lat or log.loc.lon:
context['map'] = True
context['info']['location'] = log.loc
for f in ['addr','name','city','client']:
if getattr(log,f):
context['info'][f] = getattr(log,f)
if log.extra:
try:
context['info']['extra'].update(log.extra)
except KeyError:
context['info']['extra']= dict(log.extra)
prev_curs=prev=None
if self.request.get('cursor'):
rev_curs = curs.reversed()
logs2, prev_curs, prev = query.order(-EventLog.date).fetch_page(20, start_cursor=rev_curs)
if next_curs and next:
context["next"] = next_curs.urlsafe()
if prev_curs and prev:
context["prev"] = prev_curs.urlsafe()
return context
def testlist():
# u=walkermodel.Temo(f1='aa',f2='bb',f3=1)
# u2=walkermodel.Temo(f1='aa',f2='bb',f3=2)
# u3=walkermodel.Temo(f1='aa',f2='bb',f3=3)
# ndb.put_multi([u,u2,u3])
form = testform()
if form.validate_on_submit():
item = walkermodel.Temo(f1=form.f1.data,f2=form.f2.data,f3=form.f3.data)
item.put()
flask.flash('add obj success')
return flask.redirect(flask.url_for('testlist'))
else:
next_curs, prev_curs = None, None
query = walkermodel.Temo.query()
curs = Cursor(urlsafe=flask.request.args.get('curs'))
ls, nextcurs, more = query.order(walkermodel.Temo.f3).fetch_page(3,start_cursor=curs)
if more and nextcurs:
next_curs = flask.url_for('testlist',curs=nextcurs.urlsafe())
revcurs = curs.reversed()
pls, precurs, more = query.order(-walkermodel.Temo.f3).fetch_page(3,start_cursor=revcurs)
if more and precurs:
prev_curs = flask.url_for('testlist',curs=precurs.urlsafe())
# return flask.render_template('theme/default/testlist.html',ls=ls,form=form,abc=flask.request.args.get('abc'))
return flask.render_template('theme/default/testlist.html',ls=ls,form=form,next_curs=next_curs,prev_curs=prev_curs)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
try:
qry = self.user_model.get_by_id(long(q.lower()))
count = 1 if qry else 0
except Exception as e:
logging.info('Exception at query: %s; trying with email' % e)
qry = self.user_model.get_by_email(q.lower())
count = 1 if qry else 0
users = []
if qry:
users.append(qry)
else:
qry = self.user_model.query()
count = qry.count()
PAGE_SIZE = 50
if forward:
users, next_cursor, more = qry.order(
-self.user_model.last_login).fetch_page(
PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
users, next_cursor, more = qry.order(
self.user_model.last_login).fetch_page(PAGE_SIZE,
start_cursor=cursor)
users = list(reversed(users))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-users-list', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [
('username', 'Correo'),
('name', 'Nombre'),
('last_name', 'Apellido'),
('link_referral', u'Url único'),
# ('rewards','Recompensas'),
('created', 'Registro'),
('last_login', u'Último ingreso')
],
"users":
users,
"count":
count
}
params['nickname'] = g_users.get_current_user().email().lower()
return self.render_template('usage/admin_users_list.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
try:
user_key = ndb.Key(User,long(q.lower()))
qry = LogVisit.query(ndb.OR( LogVisit.user == user_key,
LogVisit.timestamp == q.lower(),
LogVisit.uastring == q.lower(),
LogVisit.ip == q.lower()))
except:
qry = LogVisit.query(ndb.OR( LogVisit.timestamp == q.lower(),
LogVisit.uastring == q.lower(),
LogVisit.ip == q.lower()))
else:
qry = LogVisit.query()
PAGE_SIZE = 50
if forward:
visits, next_cursor, more = qry.order(LogVisit.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
visits, next_cursor, more = qry.order(-LogVisit.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
visits = list(reversed(visits))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-logs-visits', **params)
self.view.pager_url = pager_url
self.view.q = q
#fine-tuning output
_visits = []
for _visit in visits:
if(self.user_model.get_by_id(long(_visit.user.id())) != None):
_visits.append(_visit)
if self.app.config.get('app_lang') == 'es':
list_columns = [('timestamp', 'Fecha'), ('ip', 'IP'),('uastring', 'Navegador')]
else:
list_columns = [('timestamp', 'Date'), ('ip', 'IP'),('uastring', 'Browser')]
params = {
"list_columns": list_columns,
"visits": _visits,
"count": qry.count()
}
params['nickname'] = g_users.get_current_user().email().lower()
return self.render_template('%s/users/admin_logs_visits.html' % self.app.config.get('app_lang'), **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
try:
qry = self.user_model.get_by_id(long(q.lower()))
count = 1 if qry else 0
except Exception as e:
logging.info('Exception at query: %s; trying with email' % e)
qry = self.user_model.get_by_email(q.lower())
count = 1 if qry else 0
users = []
if qry:
users.append(qry)
else:
qry = self.user_model.query()
count = qry.count()
PAGE_SIZE = 50
if forward:
users, next_cursor, more = qry.order(-self.user_model.last_login).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
users, next_cursor, more = qry.order(self.user_model.last_login).fetch_page(PAGE_SIZE, start_cursor=cursor)
users = list(reversed(users))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-users-list', **params)
self.view.pager_url = pager_url
self.view.q = q
if self.app.config.get('app_lang') == 'es':
list_columns = [('username', 'Correo'),
('name', 'Nombre'),
('last_name', 'Apellido'),
('level', 'Nivel de acceso'),
('get_role', 'Rol'),
('link_referral', u'Link único'),
('amount','Recompensas'),
('created', u'Creación'),
('last_login', u'Último ingreso')
]
else:
list_columns = [('username', 'Email'),
('name', 'Name'),
('last_name', 'Lastname'),
('level', 'Access'),
('role', 'Role'),
('link_referral', u'Unique link'),
('amount','Rewards'),
('created', 'Created'),
('last_login', u'Last login')
]
params = {
"list_columns": list_columns,
"users": users,
"count": count
}
params['nickname'] = g_users.get_current_user().email().lower()
return self.render_template('%s/users/admin_users_list.html' % self.app.config.get('app_lang'), **params)
def list_process():
form = CleanUserProcessForm()
user = users.get_current_user()
clean_process_saved = False
clean_processes = []
clean_process_query = CleanUserProcess.query(CleanUserProcess.owner_email == user.email()).order()
query_params = {}
if request.method == 'POST':
if form.validate_on_submit():
primary_domain = PrimaryDomain.get_or_create(
domain_name = user.email().split('@')[1])
logged_in = 'NO'
current_user = users.get_current_user()
if current_user.email() == primary_domain.admin_email:
imap = IMAPHelper()
logged_in, _ = imap.login(
form.data['source_email'], form.data['source_password'])
imap.close()
if logged_in != 'OK':
form.source_email.errors.append(
"Can't access the email with those credentials")
else:
clean_user_process = CleanUserProcess(
owner_email=user.email(),
destination_message_email=user.email(),
status=constants.STARTED
)
for key, value in form.data.iteritems():
setattr(clean_user_process, key, value)
clean_process_key = clean_user_process.put()
clean_process_saved = True
# TODO: process does not appears immediately after it's saved
# launch Pipeline
deferred.defer(schedule_user_cleaning, user_email=form.data['source_email'],
process_id=clean_process_key.id())
is_prev = request.args.get('prev', False)
url_cursor = request.args.get('cursor', None)
cursor = Cursor(urlsafe=url_cursor) if url_cursor else None
if is_prev:
clean_process_query = clean_process_query.order(
CleanUserProcess.created)
cursor = cursor.reversed()
else:
clean_process_query = clean_process_query.order(
-CleanUserProcess.created)
data, next_curs, more = clean_process_query.fetch_page(
constants.PAGE_SIZE, start_cursor=cursor)
clean_processes.extend(data)
if is_prev:
prev_curs = next_curs.reversed().urlsafe() if more else None
next_curs = url_cursor
else:
prev_curs = url_cursor
next_curs = next_curs.urlsafe() if more else None
return render_template('process.html', form=form, user=user.email(),
clean_process_saved=clean_process_saved,
clean_processes=clean_processes, next_curs=next_curs,
more=more, prev_curs=prev_curs)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
_users = []
qry = self.user_model.query(ndb.OR(self.user_model.name >= q.lower(),
self.user_model.email >= q.lower(),
self.user_model.username >= q.lower()))
for _qry in qry:
if q.lower() in _qry.name.lower() or q.lower() in _qry.email.lower() or q.lower() in _qry.username.lower():
_users.append(_qry)
users = _users
count = len(users)
else:
qry = self.user_model.query()
count = qry.count()
PAGE_SIZE = 50
if forward:
users, next_cursor, more = qry.order(-self.user_model.last_login).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
users, next_cursor, more = qry.order(self.user_model.last_login).fetch_page(PAGE_SIZE, start_cursor=cursor)
users = list(reversed(users))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-users-list', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('username', 'Username | Email'),
('name', 'Name'),
('last_name', 'Last'),
('link_referral', 'Unique Link'),
('key', 'Key'),
('rewards','Rewards'),
('created', 'Created'),
('last_login', 'Last Login')
],
"users": users,
"count": count
}
return self.render_template('admin_users_list.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
user_key = ndb.Key(User,long(q.lower()))
qry = LogVisit.query(ndb.OR( LogVisit.user == user_key,
LogVisit.timestamp == q.lower(),
LogVisit.uastring == q.lower(),
LogVisit.ip == q.lower()))
else:
qry = LogVisit.query()
#evil things work great
temp = {}
avg = 0
ids = 0
for visit in qry:
if(self.user_model.get_by_id(long(visit.user.id())) != None):
if visit.user.id() not in temp:
temp[visit.user.id()] = 1
else:
temp[visit.user.id()] += 1
ids += 1
avg += temp[visit.user.id()]
try:
avg /= ids
except:
pass
PAGE_SIZE = 50
if forward:
visits, next_cursor, more = qry.order(LogVisit.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
visits, next_cursor, more = qry.order(-LogVisit.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
visits = list(reversed(visits))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-logs-visits', **params)
self.view.pager_url = pager_url
self.view.q = q
#fine-tuning output
_visits = []
for _visit in visits:
if(self.user_model.get_by_id(long(_visit.user.id())) != None):
_visits.append(_visit)
maxValue = 1
histogram = []
for t in temp:
histogram.append(temp[t])
if (temp[t]> maxValue):
maxValue = temp[t]
params = {
"list_columns": [('timestamp', 'Timestamp'),
('ip', 'IP'),
('uastring', 'Browser')
],
"visits": _visits,
"count": qry.count(),
"rec_visits": temp,
"avg": avg,
"histogram": histogram,
"maxValue": maxValue,
"ids": ids,
"len_hist": len(histogram)
}
return self.render_template('admin_logs_visits.html', **params)
def get(self):
try:
p = self.request.get('p')
q = self.request.get('q') ##: This is for the search which should be added to the query.
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
qry = shoppingModels.MarketMaker.query(ancestor=self.user_key) ##: TODO add the q(for search query) to this query
else:
qry = shoppingModels.MarketMaker.query(ancestor=self.user_key)
PAGE_SIZE = 5
if forward:
positions, next_cursor, more = qry.order(shoppingModels.MarketMaker.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
positions, next_cursor, more = qry.order(-shoppingModels.MarketMaker.key).fetch_page(PAGE_SIZE, start_cursor=cursor)
positions = list(reversed(positions))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('fullPagePositions', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [
('pn', 'Product Number'),
('d', 'Description'),
('bup', 'Purchase Price'),
('sup', 'Selling Price'),
('rq', 'Quantity'),
('qoh', 'Qnt. on Hold'),
('roi', 'Est. R.O.I.'),
('p', 'Markup %'),
('f', 'Fee Paid'),
],
"positions" : positions,
"count" : qry.count()
}
self.bournee_template('fullPositions.html', **params)
except Exception as e:
logging.error('Error in handler - FullPagePositionsHandler : -- {}'.format(e))
message = _('We are having difficulties displaying the Full Positions Page. Please try again later.')
self.add_message(message, 'error')
try:
self.redirect(self.request.referer)
except:
self.redirect_to('home')
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
try:
user_key = ndb.Key(User, long(q.lower()))
qry = LogVisit.query(
ndb.OR(LogVisit.user == user_key,
LogVisit.timestamp == q.lower(),
LogVisit.uastring == q.lower(),
LogVisit.ip == q.lower()))
except:
qry = LogVisit.query(
ndb.OR(LogVisit.timestamp == q.lower(),
LogVisit.uastring == q.lower(),
LogVisit.ip == q.lower()))
else:
qry = LogVisit.query()
PAGE_SIZE = 50
if forward:
visits, next_cursor, more = qry.order(LogVisit.key).fetch_page(
PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
visits, next_cursor, more = qry.order(-LogVisit.key).fetch_page(
PAGE_SIZE, start_cursor=cursor)
visits = list(reversed(visits))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-logs-visits', **params)
self.view.pager_url = pager_url
self.view.q = q
#fine-tuning output
_visits = []
for _visit in visits:
if (self.user_model.get_by_id(long(_visit.user.id())) != None):
_visits.append(_visit)
# maxValue = 1
# histogram = []
# for t in temp:
# histogram.append(temp[t])
# if (temp[t]> maxValue):
# maxValue = temp[t]
params = {
"list_columns": [('timestamp', 'Fecha'), ('ip', u'Dirección IP'),
('uastring', 'Navegador')],
"visits":
_visits,
"count":
qry.count()
# "avg": avg,
# "histogram": histogram,
# "maxValue": maxValue,
# "ids": ids,
# "len_hist": len(histogram)
}
params['nickname'] = g_users.get_current_user().email().lower()
return self.render_template('usage/admin_logs_visits.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
user_key = ndb.Key(User, long(q.lower()))
qry = LogVisit.query(
ndb.OR(LogVisit.user == user_key,
LogVisit.timestamp == q.lower(),
LogVisit.uastring == q.lower(),
LogVisit.ip == q.lower()))
else:
qry = LogVisit.query()
#evil things work great
temp = {}
avg = 0
ids = 0
for visit in qry:
if (self.user_model.get_by_id(long(visit.user.id())) != None):
if visit.user.id() not in temp:
temp[visit.user.id()] = 1
else:
temp[visit.user.id()] += 1
ids += 1
avg += temp[visit.user.id()]
try:
avg /= ids
except:
pass
PAGE_SIZE = 50
if forward:
visits, next_cursor, more = qry.order(LogVisit.key).fetch_page(
PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
visits, next_cursor, more = qry.order(-LogVisit.key).fetch_page(
PAGE_SIZE, start_cursor=cursor)
visits = list(reversed(visits))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-logs-visits', **params)
self.view.pager_url = pager_url
self.view.q = q
#fine-tuning output
_visits = []
for _visit in visits:
if (self.user_model.get_by_id(long(_visit.user.id())) != None):
_visits.append(_visit)
maxValue = 1
histogram = []
for t in temp:
histogram.append(temp[t])
if (temp[t] > maxValue):
maxValue = temp[t]
params = {
"list_columns": [('timestamp', 'Timestamp'), ('ip', 'IP'),
('uastring', 'Browser')],
"visits":
_visits,
"count":
qry.count(),
"rec_visits":
temp,
"avg":
avg,
"histogram":
histogram,
"maxValue":
maxValue,
"ids":
ids,
"len_hist":
len(histogram)
}
return self.render_template('admin_logs_visits.html', **params)
def get(self):
p = self.request.get('p')
q = self.request.get('q')
c = self.request.get('c')
forward = True if p not in ['prev'] else False
cursor = Cursor(urlsafe=c)
if q:
_users = []
qry = self.user_model.query(
ndb.OR(self.user_model.name >= q.lower(),
self.user_model.email >= q.lower(),
self.user_model.username >= q.lower()))
for _qry in qry:
if q.lower() in _qry.name.lower() or q.lower(
) in _qry.email.lower() or q.lower() in _qry.username.lower():
_users.append(_qry)
users = _users
count = len(users)
else:
qry = self.user_model.query()
count = qry.count()
PAGE_SIZE = 50
if forward:
users, next_cursor, more = qry.order(
-self.user_model.last_login).fetch_page(
PAGE_SIZE, start_cursor=cursor)
if next_cursor and more:
self.view.next_cursor = next_cursor
if c:
self.view.prev_cursor = cursor.reversed()
else:
users, next_cursor, more = qry.order(
self.user_model.last_login).fetch_page(PAGE_SIZE,
start_cursor=cursor)
users = list(reversed(users))
if next_cursor and more:
self.view.prev_cursor = next_cursor
self.view.next_cursor = cursor.reversed()
def pager_url(p, cursor):
params = OrderedDict()
if q:
params['q'] = q
if p in ['prev']:
params['p'] = p
if cursor:
params['c'] = cursor.urlsafe()
return self.uri_for('admin-users-list', **params)
self.view.pager_url = pager_url
self.view.q = q
params = {
"list_columns": [('username', 'Username | Email'),
('name', 'Name'), ('last_name', 'Last'),
('link_referral', 'Unique Link'), ('key', 'Key'),
('rewards', 'Rewards'), ('created', 'Created'),
('last_login', 'Last Login')],
"users":
users,
"count":
count
}
return self.render_template('admin_users_list.html', **params)
