def render_element_index(database_column, linked_table, folder):
shift = 0
off = int(request.args.get("offset") or 0)
entries = calibre_db.session.query(
func.upper(func.substr(database_column, 1, 1)).label('id'), None, None)
# query = calibre_db.generate_linked_query(config.config_read_column, db.Books)
if linked_table is not None:
entries = entries.join(linked_table).join(db.Books)
entries = entries.filter(calibre_db.common_filters()).group_by(
func.upper(func.substr(database_column, 1, 1))).all()
elements = []
if off == 0:
elements.append({'id': "00", 'name': _("All")})
shift = 1
for entry in entries[off + shift -
1:int(off + int(config.config_books_per_page) -
shift)]:
elements.append({'id': entry.id, 'name': entry.id})
pagination = Pagination(
(int(off) / (int(config.config_books_per_page)) + 1),
config.config_books_per_page,
len(entries) + 1)
return render_xml_template('feed.xml',
letterelements=elements,
folder=folder,
pagination=pagination)
def register():
fields = ["email", "password", "repassword"]
if _check_params(fields) != 0:
return jsonify({"result": 0, "msg": MSG_PARAMS_MISSING})
email = _g("email")
password = _g("password")
repassword = _g("repassword")
if not email:
return jsonify({"result": 0, "msg": MSG_EMAIL_BLANK_ERROR})
if not password:
return jsonify({"result": 0, "msg": MSG_PASSWORD_BLANK_ERROR})
if password != repassword:
return jsonify({"result": 0, "msg": MSG_PASSWORD_NOT_MATCH})
try:
DBSession.query(User).filter(and_(User.active == 0, func.upper(User.email) == email.upper())).one()
return jsonify({"result": 0, "msg": MSG_EMAIL_EXIST})
except:
traceback.print_exc()
pass
display_name = _g("display_name") or email
try:
u = User(email=email, password=password, display_name=display_name)
DBSession.add(u)
DBSession.commit()
return jsonify({"result": 1, "msg": MSG_SAVE_SUCCESS, "id": u.id, "point": u.point})
except:
traceback.print_exc()
return jsonify({"result": 0, "msg": MSG_SERVER_ERROR})
def feed_letter_books(book_id):
off = request.args.get("offset") or 0
letter = true() if book_id == "00" else func.upper(db.Books.sort).startswith(book_id)
entries, __, pagination = calibre_db.fill_indexpage((int(off) / (int(config.config_books_per_page)) + 1), 0,
db.Books,
letter,
[db.Books.sort])
return render_xml_template('feed.xml', entries=entries, pagination=pagination)
def feed_seriesindex():
shift = 0
off = int(request.args.get("offset") or 0)
entries = calibre_db.session.query(func.upper(func.substr(db.Series.sort, 1, 1)).label('id'))\
.join(db.books_series_link).join(db.Books).filter(calibre_db.common_filters())\
.group_by(func.upper(func.substr(db.Series.sort, 1, 1))).all()
elements = []
if off == 0:
elements.append({'id': "00", 'name':_("All")})
shift = 1
for entry in entries[
off + shift - 1:
int(off + int(config.config_books_per_page) - shift)]:
elements.append({'id': entry.id, 'name': entry.id})
pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
len(entries) + 1)
return render_xml_template('feed.xml',
letterelements=elements,
folder='opds.feed_letter_series',
pagination=pagination)
def feed_letter_author(book_id):
off = request.args.get("offset") or 0
letter = true() if book_id == "00" else func.upper(db.Authors.sort).startswith(book_id)
entries = calibre_db.session.query(db.Authors).join(db.books_authors_link).join(db.Books)\
.filter(calibre_db.common_filters()).filter(letter)\
.group_by(text('books_authors_link.author'))\
.order_by(db.Authors.sort)
pagination = Pagination((int(off) / (int(config.config_books_per_page)) + 1), config.config_books_per_page,
entries.count())
entries = entries.limit(config.config_books_per_page).offset(off).all()
return render_xml_template('feed.xml', listelements=entries, folder='opds.feed_author', pagination=pagination)
def login():
fields = ["userName", "password"]
if _check_params(fields) != 0:
return jsonify({"result": 0, "msg": MSG_PARAMS_MISSING})
username = _g("userName")
password = _g("password")
if not username:
return jsonify({"result": 0, "msg": MSG_EMAIL_BLANK_ERROR})
if not password:
return jsonify({"result": 0, "msg": MSG_PASSWORD_BLANK_ERROR})
try:
user = DBSession.query(User).filter(and_(User.active == 0, func.upper(User.email) == username.upper())).one()
if user.password != password:
return jsonify({"result": 0, "msg": MSG_WRONG_PASSWORD})
except:
return jsonify({"result": 0, "msg": MSG_USER_NOT_EXIST})
return jsonify({"result": 1, "msg": MSG_VALIDATE_SUCCESS, "data": {"uid": user.id, "name": unicode(user)}})
def find_by_short_id(self,short_id):
return session().query(OperationDefinition).filter(func.upper(OperationDefinition.short_id) == func.upper(short_id)).first()
def bind_expression(self, bindvalue):
# applies specialfunc to create e.g. "WHERE mycol > specialfunc(%s)"
print "BIND_EXPRESSION"
return func.upper(bindvalue, type_=self)
def unique_filter(cls, query, name):
return query.filter(func.upper(RefType.name) == name.upper())
def f(session):
if gene_names is not None and len(gene_names) > 0:
upper_gene_names = [x.upper() for x in gene_names]
fs_by_name = set(session.query(Feature).filter(func.upper(Feature.name).in_(upper_gene_names)).filter(Feature.type != 'chromosome').all())
fs_by_gene_name = set(session.query(Feature).filter(func.upper(Feature.gene_name).in_(upper_gene_names)).filter(Feature.type != 'chromosome').all())
log_it('DB_query', 'SUCCESS')
all_names_left = set(upper_gene_names)
#Create table mapping name -> Feature
name_to_feature = {}
for f in fs_by_name:
name_to_feature[f.name.upper()] = f
for f in fs_by_gene_name:
name_to_feature[f.gene_name.upper()] = f
all_names_left.difference_update(name_to_feature.keys())
if len(all_names_left) > 0:
aliases = session.query(Alias).filter(func.upper(Alias.name).in_(all_names_left)).all()
else:
aliases = []
log_it('Create table mapping feature', 'SUCCESS')
#Create table mapping name -> Alias
name_to_alias = {}
for a in aliases:
features = [f for f in a.features if f.type != 'chromosome']
if len(features) > 0:
if a.name in name_to_alias:
name_to_alias[a.name.upper()].update(features)
else:
name_to_alias[a.name.upper()] = set(features)
log_it('Create table mapping alias', 'SUCCESS')
#This may be a gene name with p appended
p_endings = [word[:-1] for word in all_names_left if word.endswith('P')]
p_ending_fs_by_name = set()
p_ending_fs_by_gene_name = set()
if len(p_endings) > 0:
p_ending_fs_by_name.update(session.query(Feature).filter(func.upper(Feature.name).in_(p_endings)).filter(Feature.type != 'chromosome').all())
p_ending_fs_by_gene_name.update(session.query(Feature).filter(func.upper(Feature.gene_name).in_(p_endings)).filter(Feature.type != 'chromosome').all())
all_names_left.difference_update(name_to_alias.keys())
log_it('p appended', 'SUCCESS')
#Add to Alias table all p-ending gene names
for p_ending in p_ending_fs_by_name:
word = p_ending.name + 'P'
if word in name_to_alias:
name_to_alias[word.upper()].add(p_ending)
else:
name_to_alias[word.upper()] = set([p_ending])
for p_ending in p_ending_fs_by_gene_name:
word = p_ending.gene_name + 'P'
if word in name_to_alias:
name_to_alias[word.upper()].add(p_ending)
else:
name_to_alias[word.upper()] = set([p_ending])
log_it('Add to alias table', 'SUCCESS')
alias_message = create_alias_message(name_to_alias)
feature_message = create_feature_message(name_to_feature)
not_genes_message = create_not_genes_message(all_names_left)
log_it('Create messages', 'SUCCESS')
return {'features':name_to_feature, 'aliases':name_to_alias, 'not_genes':all_names_left, 'alias_message':alias_message, 'feature_message':feature_message, 'not_genes_message':not_genes_message}
else:
return {'features':{}, 'aliases':{}, 'not_genes':set(), 'alias_message':'', 'feature_message':'', 'not_genes_message':''}
def __eq__(self, other):
return func.upper(self.__clause_element__()) == func.upper(other)
