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)