def prepareForProjectDataTable(self): """ 为实验项目数据表格 :return: """ def _arrangeProjectDatas(_data_collection): _middle_arrange = {} for _raw_data in _data_collection: if not _raw_data.row_id in _middle_arrange: _middle_arrange[_raw_data.row_id] = {} _middle_arrange[_raw_data.row_id].setdefault(_raw_data.label, _raw_data) for _middle_data in _middle_arrange: for _property in properties: if not _property.label in _middle_arrange[_middle_data]: _middle_arrange[_middle_data][_property.label] = None return _middle_arrange # TODO 组合项目数据表格,使body和head对应 pid, = self.requestParams("pid") if self.checkParamsAvailable(pid): project = db_session.query(Project).filter(Project.id==pid).first() if project is not None: project_data = {} properties = db_session.query(ProjectProperty).filter(ProjectProperty.p_id==pid).all() data_records = db_session.query(ProjectItem).filter(ProjectItem.proj_id==pid).all() project_data.setdefault('project', project) project_data.setdefault('properties', properties) project_data.setdefault('records', _arrangeProjectDatas(data_records)) self.setData(project_data) self.changeResponse2Success() else: self.setFailureReason("实验项目不存在!")
def update_account(request): data = json.loads(request.data) if request.data else None if not data: return jsonify(error = True, message = "request data not provided") if 'displayname' not in data: return jsonify(error = True, message = "displayname not provided in request data") if 'email' not in data: return jsonify(error = True, message = "email not provided in request data") displayname = cgi.escape( data['displayname'] ) email = cgi.escape( data['email'] ) if not displayname: return jsonify(error = True, message = "displayname must have value") you = db_session.query(Users).filter_by(id = user_session['you_id']).one() you.displayname = displayname if you.email != email: check_email = db_session.query(Users).filter_by(email = email).first() if check_email: return jsonify(error = True, message = "Email is already in use") you.email = email db_session.add(you) db_session.commit() return jsonify(message = "Account Updated!", you = you.serialize)
def check_booking_request(request, sse, event_id, account_id): your_id = user_session['account_id'] if account_id == your_id: return jsonify( error=True, message= 'forbidden: provided account_id is equal to current account_id') event = db_session.query(Events).filter_by(id=event_id).first() if event == None: return jsonify(error=True, message='no event found by id: ' + str(event_id)) if event.host_id != your_id and event.host_id != account_id: return jsonify(error=True, message='none of the two accounts own this event') booking_request = db_session.query(EventRequests) \ .filter(EventRequests.event_id == event_id) \ .filter( (EventRequests.sender_id == your_id) | (EventRequests.receiver_id == your_id) ) \ .filter( (EventRequests.sender_id == account_id) | (EventRequests.receiver_id == account_id) ) \ .first() if booking_request: return jsonify(message='booking request exists', booking_request_exists=True, booking_request=booking_request.serialize) else: return jsonify(message='no booking request exists', booking_request_exists=False)
def get_conversation_messages(request, sse, c_id, cm_id): try: if cm_id == 0: conversation_messages = db_session.query(ConversationMessages) \ .filter(ConversationMessages.conversation_id == c_id) \ .order_by(desc(ConversationMessages.date_created)) \ .limit(5) \ .all() else: conversation_messages = db_session.query(ConversationMessages) \ .filter(ConversationMessages.conversation_id == c_id) \ .filter(ConversationMessages.id < cm_id) \ .order_by(desc(ConversationMessages.date_created)) \ .limit(5) \ .all() return jsonify(message='conversation messages', conversation_messages=[ cm.serialize for cm in conversation_messages ]) except Exception as err: print(err) return jsonify(error=True, errorMessage=str(err), message='error processing...')
def get_event_comments(request, sse, event_id, comment_id): try: if comment_id == 0: event_comments = db_session.query(EventComments) \ .filter(EventComments.event_id == event_id) \ .order_by(desc(EventComments.date_created)) \ .limit(5) \ .all() else: event_comments = db_session.query(EventComments) \ .filter(EventComments.event_id == event_id) \ .filter(EventComments.id < comment_id) \ .order_by(desc(EventComments.date_created)) \ .limit(5) \ .all() return jsonify(message='event comments', event_comments=[ec.serialize for ec in event_comments]) except Exception as err: print(err) return jsonify(error=True, errorMessage=str(err), message='error processing...')
def get_event_likes(request, sse, event_id, like_id): try: if like_id == 0: likes = db_session.query(EventLikes) \ .filter(EventLikes.event_id == event_id) \ .order_by(desc(EventLikes.date_created)) \ .limit(5) \ .all() else: likes = db_session.query(EventLikes) \ .filter(EventLikes.event_id == event_id) \ .filter(EventLikes.id < like_id) \ .order_by(desc(EventLikes.date_created)) \ .limit(5) \ .all() return jsonify(message='event likes', likes=[l.serialize for l in likes]) except Exception as err: print(err) return jsonify(error=True, errorMessage=str(err), message='error processing...')
def get_event_attending(request, sse, event_id, attend_id): try: if attend_id == 0: attending = db_session.query(EventAttendees) \ .filter(EventAttendees.event_id == event_id) \ .order_by(desc(EventAttendees.date_created)) \ .limit(5) \ .all() else: attending = db_session.query(EventAttendees) \ .filter(EventAttendees.event_id == event_id) \ .filter(EventAttendees.id < attend_id) \ .order_by(desc(EventAttendees.date_created)) \ .limit(5) \ .all() return jsonify(message='event attending', attending=[a.serialize for a in attending]) except Exception as err: print(err) return jsonify(error=True, errorMessage=str(err), message='error processing...')
async def channel_ignore_list(self, ctx: Context): ignored_channels = [ f" • {c.mention}" for c in ctx.guild.text_channels if c.id in list(db_session.query(IgnoredChannel).all()) ] mini_karma_channels = [ f" • {c.mention}" for c in ctx.guild.text_channels if c.id in (list(db_session.query(MiniKarmaChannel).all())) ] message = [] if ignored_channels: message += ["Ignored channels:"] + ignored_channels if ignored_channels and mini_karma_channels: message.append("") if mini_karma_channels: message += ["", "Mini-karma Channels:"] + mini_karma_channels if message: await ctx.send("\n".join(message)) else: await ctx.send("No channels are ignored or on mini-karma mode.")
def update_booking_email(request, sse): try: data = json.loads(request.data) if not data: return jsonify(error=True, message='request body is empty, check headers/data') booking_email = str(data['booking_email']).encode() check_email = db_session.query(Accounts).filter_by( booking_email=booking_email).first() if check_email: return jsonify(error=True, message='booking account email is already in use') you = db_session.query(Accounts).filter_by( id=user_session['account_id']).one() you.booking_email = booking_email db_session.add(you) db_session.commit() return jsonify(account=you.serialize, message='Booking Email Updated Successfully!') except Exception as err: print(err) return jsonify(error=True, errorMessage=str(err), message='error processing...')
def handleRegister(self): """ 处理用户注册 :return: """ name, email, pwd = self.postParams('name', 'email', 'pwd') if self.checkParamsAvailable(email, pwd): exists_query = db_session.query(User).filter(User.email==email).exists() if not db_session.query(exists_query).scalar(): try: set_user = User() set_user.name = name set_user.email = email set_user.salt = User.genSalt() set_user.pwd = User.genPassword(pwd, set_user.salt) set_user.reg_ip = str(request.remote_addr) db_session.add(set_user) db_session.commit() self.changeResponse2Success() mailer = getMailSender() mailer.setMailtoList([email]) mailer.setSubject("感谢注册 [史前-在线定量研究工具]") _mail_content = render_template("noticer/email/_register.html", nickname=name) mailer.setContent(_mail_content) mailer.send() except Exception as e: db_session.rollback() self.setFailureReason(str(e)) else: self.setFailureReason("该邮箱已经被注册,请更换邮箱申请或尝试找回密码!")
def toggle_comment_like(request, sse, comment_id): comment = db_session.query(EventComments).filter_by(id=comment_id).first() if not comment: return jsonify(error=True, message='comment not found') like = db_session.query(CommentLikes) \ .filter_by(comment_id = comment_id) \ .filter_by(owner_id = user_session['account_id']) \ .first() if like: db_session.delete(like) check_notification = db_session.query(Notifications) \ .filter(Notifications.action == ACTION_TYPES['COMMENT_LIKE']) \ .filter(Notifications.target_type == TARGET_TYPES['COMMENT']) \ .filter(Notifications.target_id == like.comment_id) \ .filter(Notifications.from_id == user_session['account_id']) \ .filter(Notifications.account_id == like.comment_rel.owner_id) \ .first() if check_notification: db_session.delete(check_notification) db_session.commit() return jsonify(message='unliked', liked=False) else: like = CommentLikes(comment_id=comment_id, owner_id=user_session['account_id']) db_session.add(like) db_session.commit() if like.comment_rel.owner_id != user_session['account_id']: you = db_session.query(Accounts).filter_by( id=user_session['account_id']).one() message = you.username + ' liked your comment: ' + like.comment_rel.text new_notification = Notifications( action=ACTION_TYPES['COMMENT_LIKE'], target_type=TARGET_TYPES['COMMENT'], target_id=like.comment_id, from_id=user_session['account_id'], account_id=like.comment_rel.owner_id, message=message, link='/event/' + str(like.comment_rel.event_rel.id)) db_session.add(new_notification) db_session.commit() sse.publish( { "message": message, "for_id": like.comment_rel.owner_id }, type='action') return jsonify(message='liked', liked=True)
def handleRemoveGeopointGroup(self): """ 删除指定的整个地理坐标集合 需要校验地理坐标集合是否属于操作者本人 :return: """ gid, pwd = self.postParams("gid", "pwd") if self.checkParamsAvailable(gid, pwd): if self.userIdentification(pwd): current_user = UserIdentify() geo_group_info = db_session.query(GeoPointGroup).filter(GeoPointGroup.id==gid).first() if geo_group_info is not None: if (geo_group_info.u_id == current_user.uid): try: # 删除集合下的所有观察子节点 db_session.query(GeoPointUnit).filter(GeoPointUnit.group_id==gid).delete() db_session.delete(geo_group_info) db_session.commit() self.changeResponse2Success() except Exception as e: self.setFailureReason(str(e), redirect_url=url_for(".ViewGeoGroup", gid=gid)) else: self.setFailureReason("该地理坐标点位集合不属于您,无法执行删除操作!", redirect_url=url_for(".ViewGeoGroup", gid=gid)) else: self.setFailureReason("指定的地理坐标点位集合不存在!", redirect_url=url_for(".ViewGeoGroup", gid=gid)) else: self.setFailureReason("对不起,您不具备执行当前操作的权限!", redirect_url=url_for(".ViewGeoGroup", gid=gid))
def rest_endpoint_handler(): id = request.args.get('id') if id is not None: user = db_session.query(UsersModel).filter(UsersModel.id == id).first() followers = db_session.query( FollowsModel.follow_by).filter(FollowsModel.follow_to == id).all() d = dict() d['firstName'] = user.firstName d['lastName'] = user.lastName d['username'] = user.username d['email'] = user.email l = list() for follower in followers: l.append('/rest/user/?id=' + str(follower[0])) d['followers'] = l return jsonify(resultSet=d) else: users = db_session.query(UsersModel).filter().all() l1 = list() for user in users: followers = db_session.query(FollowsModel.follow_by).filter( FollowsModel.follow_to == user.id).all() d = dict() d['firstName'] = user.firstName d['lastName'] = user.lastName d['username'] = user.username d['email'] = user.email l = list() for follower in followers: l.append('/rest/user/?id=' + str(follower[0])) d['followers'] = l l1.append(d) return jsonify(resultSet=l1)
async def add(self, ctx: Context, item: str): author_id = ( db_session.query(User) .filter(User.user_uid == ctx.message.author.id) .first() .id ) if ( not db_session.query(BlockedKarma) .filter(BlockedKarma.topic == item.casefold()) .all() ): blacklist = BlockedKarma(topic=item.casefold(), user_id=author_id) db_session.add(blacklist) try: db_session.commit() await ctx.send(f"Added {item} to the karma blacklist. :pencil:") except (ScalarListException, SQLAlchemyError): db_session.rollback() await ctx.send( f"Something went wrong adding {item} to the karma blacklist. No change has occurred" ) else: await ctx.send( f"{item} is already in the karma blacklist. :page_with_curl:" )
def validate_timestamp_and_nonce(self, client_key, timestamp, nonce, request_token=None, access_token=None): filters = [ Nonce.nonce == nonce, Nonce.timestamp == timestamp, Client.id == Nonce.client_id, Client.client_key == client_key ] if request_token: filters.extend([ RequestToken.id == Nonce.request_token_id, RequestToken.token == request_token ]) if access_token: filters.extend([ AccessToken.id == Nonce.access_token_id, AccessToken.token == access_token ]) try: db_session.query(Nonce, Client, ResourceOwner).filter(*filters).one() return False except NoResultFound: return True
def handleUpdateProjectDataRecord(self): ''' 更新研究项目中的一行数据 :return: ''' _data_dict = self.postParams("*") if "pid" in _data_dict and "row_id" in _data_dict: try: project_id = int(_data_dict.get("pid", 0)) row_id = _data_dict.get("row_id", '') except Exception: project_id = 0 if project_id > 0 and '' != row_id: try: db_session.query(ProjectItem).filter(ProjectItem.proj_id==project_id).filter(ProjectItem.row_id==row_id).delete() for _d in _data_dict: if "pid" != _d and "row_id" != _d: pproperty_item = db_session.query(ProjectProperty).filter(ProjectProperty.label==_d).first() if pproperty_item is not None: p_item = ProjectItem() p_item.label = _d p_item.value = _data_dict[_d] p_item.row_id = row_id p_item.proj_id = project_id p_item.p_id = pproperty_item.id db_session.add(p_item) db_session.commit() self.changeResponse2Success() except Exception as e: db_session.rollback() self.setFailureReason(str(e)) else: self.setFailureReason('缺少关键参数!')
def update_username(request, sse): try: data = json.loads(request.data) if not data: return jsonify(error=True, message='request body is empty, check headers/data') username = str(data['username']).encode() check_username = db_session.query(Accounts).filter_by( username=username).first() if check_username: return jsonify(error=True, message='username is already in use') you = db_session.query(Accounts).filter_by( id=user_session['account_id']).one() you.username = username db_session.add(you) db_session.commit() return jsonify(account=you.serialize, message='Username Updated Successfully!') except Exception as err: print(err) return jsonify(error=True, errorMessage=str(err), message='error processing...')
def search_events(request, sse, search_type, search_query): try: search_type = str(search_type).encode().lower() types = set(['location', 'category']) if search_type not in types: return jsonify(error=True, message='search type is unknown/invalid: ' + search_type) search_query = str(search_query).encode().lower().replace( '_space_', ' ').replace('%20', ' ') query = '%' + str(cgi.escape(search_query)).encode().lower() + '%' if search_type == 'location': events = db_session.query(Events) \ .filter( func.lower(Events.location).like( query ) ) \ .order_by(func.random()) \ .limit(10).all() if search_type == 'category': events = db_session.query(Events) \ .filter( func.lower(Events.categories).like( query ) ) \ .order_by(func.random()) \ .limit(10).all() return jsonify(message='events', events=[e.serialize_small for e in events]) except Exception as err: print(err) return jsonify(error=True, errorMessage=str(err), message='error processing...')
async def listf(self, ctx: Context, *filter: clean_content): # If there is a search filter then use it if filter: filter_str = str(filter[0]) filaments = (db_session.query(FilamentType).filter( FilamentType.name.ilike(f"%{filter_str}%")).order_by( FilamentType.name).all()) else: filaments = db_session.query(FilamentType).order_by( FilamentType.name).all() if filaments: # Format the list nicely filament_list = "\n".join( map(lambda x: f" • **{x.name}** - £{x.cost}/kg", filaments)) if len(filament_list) > 1: await ctx.send(f"Our current filaments:\n{filament_list}") else: await ctx.send(f"Our current filament:\n{filament_list}") else: if filter: await ctx.send( f'There are no filaments that match "{str(filter[0])}"') else: await ctx.send("There are no filaments currently listed")
async def reminder_check(bot): await bot.wait_until_ready() while not bot.is_closed(): now = datetime.now() # I have this useless variable because its not pep8 if you compare directly to False lol not_triggered = False reminders = ( db_session.query(Reminder) .filter(Reminder.trigger_at <= now, Reminder.triggered == not_triggered) .all() ) for r in reminders: if r.irc_name: display_name = r.irc_name else: author_uid = ( db_session.query(User).filter(User.id == r.user_id).first().user_uid ) display_name = f"<@{author_uid}>" channel = bot.get_channel(r.playback_channel_id) message = f"Reminding {display_name}: " + r.reminder_content await channel.send(message) r.triggered = True db_session.commit() await asyncio.sleep(CONFIG.REMINDER_SEARCH_INTERVAL)
def deleteById(object, item_id): try: db_session.query(type(object)).filter_by(id=item_id).delete() db_session.commit() except: db_session.rollback() finally: closeDbSession()
async def remove(self, ctx: Context, item: str): if not db_session.query(BlockedKarma).filter(BlockedKarma.topic == item.casefold()).all(): await ctx.send(f'{item} is not in the karma blacklist. :page_with_curl:') else: db_session.query(BlockedKarma).filter(BlockedKarma.topic == item.casefold()).delete() db_session.commit() await ctx.send(f'{item} has been removed from the karma blacklist. :wastebasket:')
def mutate(self, info, input): data = input_to_dictionary(input) data['edited'] = datetime.utcnow() schedule = db_session.query(ScheduleModel).filter_by(id=data['id']) schedule.update(data) db_session.commit() schedule = db_session.query(ScheduleModel).filter_by(id=data['id']).first() return UpdateSchedule(schedule=schedule)
def loadPropertiesOfProject(self, pid): """ 读取指定id项目下的字段属性列表 :param pid: :return: """ project_exists = db_session.query(Project).filter(Project.id==pid).exists() return db_session.query(ProjectProperty).filter(ProjectProperty.p_id==pid).all() \ if db_session.query(project_exists).scalar() else []
def mutate(self, info, input): data = input_to_dictionary(input) data['edited'] = datetime.utcnow() message = db_session.query(MessageModel).filter_by(id=data['id']) message.update(data) db_session.commit() message = db_session.query(MessageModel).filter_by(id=data['id']).first() return UpdateMessage(message=message)
def mutate(self, info, input): data = input_to_dictionary(input) data['edited'] = datetime.utcnow() relationship = db_session.query(RelationshipModel).filter_by(id=data['id']) relationship.update(data) db_session.commit() relationship = db_session.query(RelationshipModel).filter_by(id=data['id']).first() return UpdateRelationship(relationship=relationship)
def validate_verifier(self, client_key, resource_owner_key, verifier): try: db_session.query(RequestToken, Client).filter( Client.client_key == client_key, RequestToken.token == resource_owner_key, RequestToken.verifier == verifier).one() return True except NoResultFound: return False
def mutate(self, info, input): data = input_to_dictionary(input) data['edited'] = datetime.utcnow() doctor = db_session.query(DoctorModel).filter_by(id=data['id']) doctor.update(data) db_session.commit() doctor = db_session.query(DoctorModel).filter_by(id=data['id']).first() return UpdateDoctor(doctor=doctor)
async def channel_ignore(self, ctx: Context, channel: TextChannel, mode: ChannelIgnoreMode.get = None): ignored_channel = (db_session.query(IgnoredChannel).filter( IgnoredChannel.channel == channel.id).first()) if mode == ChannelIgnoreMode.Ignore: if ignored_channel is None: # Create a new entry user = (db_session.query(User).filter( User.user_uid == ctx.author.id).first()) new_ignored_channel = IgnoredChannel( channel=channel.id, user_id=user.id, ) db_session.add(new_ignored_channel) try: db_session.commit() await ctx.send( f"Added {channel.mention} to the ignored list.") except SQLAlchemyError as e: db_session.rollback() logging.error(e) await ctx.send( "Something went wrong. No change has occurred.") else: # Entry already present await ctx.send(f"{channel.mention} is already ignored!") elif mode == ChannelIgnoreMode.Watch: if ignored_channel is not None: # Remove the entry db_session.query(IgnoredChannel).filter( IgnoredChannel.channel == channel.id).delete() try: db_session.commit() await ctx.send( f"{channel.mention} is no longer being ignored.") except SQLAlchemyError as e: db_session.rollback() logging.error(e) await ctx.send( "Something went wrong. No change has occurred.") else: # The entry is not present await ctx.send( f"{channel.mention} is not currently being ignored.") else: # Report status if ignored_channel is not None: await ctx.send(f"{channel.mention} is currently being ignored." ) else: await ctx.send( f"{channel.mention} is not currently being ignored")
def post(): title = u'文章列表' posts = db_session.query(Article).order_by( Article.data_publish.desc()).all() authors = db_session.query(User.id, User.username).all() db_session.close() return render_template('articles.html', posts=posts, title=title, authors=authors)
def show_post(p_id): title = u'文章详情' # p_id = request.args.get('p_id') posts = (db_session.query(Article).filter(Article.id == p_id).first()) author = db_session.query(User.username).filter( Article.user_id == User.id, Article.id == p_id).first()[0] return render_template('article_details.html', post=posts, title=title, author=author)
def validate_verifier(self, client_key, resource_owner_key, verifier): try: db_session.query(RequestToken, Client).filter( Client.client_key == client_key, RequestToken.token == resource_owner_key, RequestToken.verifier == verifier ).one() return True except NoResultFound: return False
def mutate(self, info, input): data = input_to_dictionary(input) data['edited'] = datetime.utcnow() hospital = db_session.query(HospitalModel).filter_by(id=data['id']) hospital.update(data) db_session.commit() hospital = db_session.query(HospitalModel).filter_by( id=data['id']).first() return UpdateHospital(hospital=hospital)
def mutate(self, info, input): data = input_to_dictionary(input) data['edited'] = datetime.utcnow() question = db_session.query(QuestionModel).filter_by(id=data['id']) question.update(data) db_session.commit() question = db_session.query(QuestionModel).filter_by( id=data['id']).first() return UpdateQuestion(question=question)
def validate_access_token(self, client_key, resource_owner_key): try: db_session.query(AccessToken, Client).filter( Client.client_key == client_key, Client.id == AccessToken.client_id, AccessToken.token == resource_owner_key).one() return True except NoResultFound: return False
def signup(request, sse): try: data = json.loads(request.data) if not data: return jsonify(error=True, message='request body is empty, check headers/data') print(data) username = str(data['username']).encode() account_email = str(data['account_email']).encode() booking_email = str(data['booking_email']).encode() account_type = str(data['account_type']).encode() password = str(data['password']).encode() hashed = bcrypt.hashpw(password, bcrypt.gensalt()) check_username = db_session.query(Accounts).filter_by( username=username).first() check_account_email = db_session.query(Accounts).filter_by( email=account_email).first() check_booking_email = db_session.query(Accounts).filter_by( booking_email=booking_email).first() if check_username: return jsonify(error=True, message='username is already in use') if check_account_email: return jsonify(error=True, message='account email is already in use') if check_booking_email: return jsonify(error=True, message='booking email is already in use') new_account = Accounts(username=username, email=account_email, booking_email=booking_email, password=hashed, type=account_type) db_session.add(new_account) db_session.commit() session_id = chamber.uniqueValue() user_session['session_id'] = session_id user_session['account_id'] = new_account.id user_session['account_type'] = new_account.type return jsonify(message='Signed Up!') except Exception as err: print(err) return jsonify(error=True, errorMessage=str(err), message='error signing up...')
def _whoami( self, name, alias_contain=True, forward_match=False, partial_match=False, backward_match=False, one=False): """ nameからUserを探す。 User.admin User.enable if True in [pr.active for pr in User.personal_records]: といった真偽値で、操作が可能かどうか判定するため、たいていの操作はここから始まる。 forward_match, partial_match, backward_matchのどれかをTrueに指定する場合は、 どれか1つだけにしなければならない。 nameの末尾のアンダースコアは取り除かれる。 IRCの事情をケアする仕様。 """ # 前方一致、部分一致、後方一致 if forward_match or partial_match or backward_match: if forward_match: base = u"%s%%" if partial_match: base = u"%%%s%%" if backward_match: base = u"%%%s" users = db_session.query(User ).filter(User.enable==True ).filter(User.name.like(base % self._rstrip_underscore(name)) ).all() if alias_contain: aliases = db_session.query(UserAlias ).filter(UserAlias.name.like(base % name) ).all() for alias in aliases: if alias.user.enable and (alias.user not in users): users.append(alias.user) # 唯一の該当者だった場合のみ結果がほしい場合 if one: if len(users) == 1: return users[0] else: return None else: return users if users else None # 完全一致 else: try: return db_session.query(User ).filter(User.name==self._rstrip_underscore(name) ).filter(User.enable==True ).one() except NoResultFound: pass if alias_contain: try: alias = db_session.query(UserAlias).filter(UserAlias.name==name).one() return alias.user if alias.user.enable else None except NoResultFound: pass return None
def validate_access_token(self, client_key, resource_owner_key): try: db_session.query(AccessToken, Client).filter( Client.client_key == client_key, Client.id == AccessToken.client_id, AccessToken.token == resource_owner_key ).one() return True except NoResultFound: return False
def validate_request_token(self, client_key, resource_owner_key): # TODO: make client_key optional if client_key: db_session.query(RequestToken, Client).filter( RequestToken.token == resource_owner_key, Client.client_key == client_key).one() else: RequestToken.query.filter_by(token=resource_owner_key).one() try: return True except NoResultFound: return False
def handleDeleteProjectDataRecord(self): ''' 删除研究项目中的一行数据 :return: ''' pid, row_id = self.postParams("pid", "row_id") if self.checkParamsAvailable(pid, row_id): try: db_session.query(ProjectItem).filter(ProjectItem.proj_id==pid).filter(ProjectItem.row_id==row_id).delete() db_session.commit() self.changeResponse2Success() except Exception as e: db_session.rollback()
def loadValueLabel(self): """ 获取有序变量的取值 :return: """ _lb = self.value property_rel = db_session.query(ProjectProperty).filter(ProjectProperty.id==self.p_id).first() if property_rel is not None and property_rel.type == ProjectProperty.TYPE_SEQUENCE: property_option = db_session.query(PropertyOptions).filter(PropertyOptions.p_id==self.p_id).\ filter(PropertyOptions.label==self.value).first() if property_option is not None: _lb = property_option.name return _lb
def fix_result(self, json): """勝敗をつけ直す。""" args = loads(json) print args user = self._whoami(args["caller"]) if user is None: return dumps((False,)) if type(args["room_id"]) == int: try: gr = db_session.query(GeneralRecord ).filter(GeneralRecord.id==args["room_id"] ).one() except NoResultFound: return dumps((False,)) if gr.completed_at is None: return dumps((False,)) # 管理者かホスト自身だけが結果を訂正できる if (not user.admin) and (user.name != gr.room_owner): return dumps((False,)) owner_pr = self._get_owner_pr(gr) else: try: # UserのPersonalRecordのうち最新のレコードを取得 pr_id = db_session.query( func.max(PersonalRecord.id) ).correlate(PersonalRecord ).filter(PersonalRecord.user_id==user.id).one()[0] pr = db_session.query(PersonalRecord ).filter(PersonalRecord.id==pr_id).one() except NoResultFound: return dumps((False,)) gr = pr.general_record if (gr.room_owner != pr.user.name) or (gr.completed_at is None): return dumps((False,)) owner_pr = pr self._save_result(owner_pr, args["won"], rollback=True) gr = owner_pr.general_record members = [] for member in gr.personal_records: # 勝敗のついた参加者のみに限定する(入って抜けた人は除外) if member.won is not None: members.append(member) returns = self._construct_room_info(gr, user) returns.update({"members": [self._construct_member_info(member) for member in members]}) return dumps((True, returns))
def handleUpdateGeoUnit(self): """ 处理地理坐标信息的更新操作 :return: """ gid, pid, geo_name, longitude, latitude, desc, area, high, map_type = \ self.postParams("gid", "pid", "geo_name", "longitude", "latitude", "desc", "area", "high", "map_type") if self.checkParamsAvailable(gid, pid, geo_name, longitude, latitude, desc, area, high, map_type): try: current_user = UserIdentify.getCurrentUser() geo_unit = db_session.query(GeoPointUnit).filter(GeoPointUnit.id==pid).first() geo_unit.name = geo_name geo_unit.longitude = longitude geo_unit.latitude = latitude geo_unit.desc = desc geo_unit.map_type = map_type if str(high).isdigit(): geo_unit.high = high else: geo_unit.high = 0 if str(area).isdigit(): geo_unit.area = area else: geo_unit.area = 0 geo_unit.u_id = current_user.get('uid', 0) db_session.add(geo_unit) db_session.commit() self.changeResponse2Success() except Exception as e: db_session.rollback() self.setFailureReason(str(e))
def insert_data(self, data): """ Will handle inserting data into the database """ try: # Check if book is in database, if so update else create try: book = db_session.query(Book).filter(Book.book_id == data.get('book_id')).one() except NoResultFound: book = Book() book.title = data.get('title') book.subtitle = data.get('subtitle') book.author = data.get('author') book.year = data.get('year') book.pages = data.get('pages') book.language = data.get('language') book.publisher = data.get('publisher') book.isbn = data.get('isbn') book.format = data.get('format') book.description = data.get('description') book.file_source = data.get('file_source') book.file_cover_source = data.get('file_cover_source') book.file_location = data.get('file_location') book.file_cover_location = data.get('file_cover_location') book.book_id = data.get('book_id') book.time_collected = data.get('time_collected') db_session.add(book) db_session.commit() # self.track_stat('rows_added_to_db', rows_affected) except Exception: db_session.rollback() logger.exception("Error adding to db {data}".format(data=data))
def handleViewLaborary(self): """ 提取展示定量实验室需要的数据 :return: """ lid, = self.getParams("lid") if self.checkParamsAvailable(lid): view_datas = {} laborary_item = db_session.query(Laborary).filter(Laborary.id==lid).first() if laborary_item is not None: projects_list = db_session.query(Project).filter(Project.l_id==lid).all() view_datas['projects'] = projects_list view_datas['laborary'] = laborary_item.toDict() self.setData(view_datas) self.changeResponse2Success()
def handleAddProjectDataRecord(self): _data_dict = self.postParams("*") if "pid" in _data_dict: try: project_id = int(_data_dict.get('pid')) except Exception as e: project_id = 0 if project_id > 0: row_num = str(uuid1()) try: for _d in _data_dict: if "pid" != _d: pproperty_item = db_session.query(ProjectProperty).\ filter(ProjectProperty.label==_d).\ filter(ProjectProperty.p_id==project_id).first() if pproperty_item is not None: p_item = ProjectItem() p_item.label = _d p_item.value = _data_dict[_d] p_item.row_id = row_num p_item.proj_id = project_id p_item.p_id = pproperty_item.id db_session.add(p_item) db_session.commit() self.changeResponse2Success() except Exception as e: db_session.rollback() self.setFailureReason(str(e))
def _diff_session(self, user): """ make_room(新規ゲーム), join_room(参加表明)のとき、会員のFQDNとIPアドレスが 前回の記録から変わっているかどうか調べて、 変わっている場合には何から何に変わったのかを返す。 """ diff = {} diff_ = False sessions = db_session.query(Session ).filter(Session.user_id == user.id ).order_by(Session.id.desc() ).limit(2 ).all() if len(sessions) == 2: last, prev = sessions if (not None in [last.ipaddr, prev.ipaddr]) and (last.ipaddr != prev.ipaddr): diff_ = True if last.hostname != prev.hostname: diff_ = True if diff_: diff.update({ "username": user.name, "last_ipaddr": last.ipaddr, "last_hostname": last.hostname, "last_timestamp": last.timestamp, "prev_ipaddr": prev.ipaddr, "prev_hostname": prev.hostname, "prev_timestamp": prev.timestamp, }) return diff
def get(self, id): try: dog = db_session.query(Dog).filter(Dog.id == id).one() t = Template('<img alt="dog_image" src="data:image/jpeg;base64,{{ img }}" />') self.write(t.generate(img=dog.image)) except: self.write("Dog not found")
def breakup(self, json): """解散、強制解散""" args = loads(json) print args user = self._whoami(args["caller"]) if user is None: return dumps((False,)) pr = self._is_room_owner(args["channel"], args["caller"]) if (not pr) and (not args["force"]): return dumps((False,)) if (not pr) and args["force"]: q = db_session.query(GeneralRecord ).filter(GeneralRecord.active==True ).filter(GeneralRecord.room_number==args["room_number"] ).filter(GeneralRecord.channel==args["channel"]) try: gr = q.one() except NoResultFound: return dumps((False,)) else: gr = pr.general_record members = self._execute_breakup(gr) returns = self._construct_room_info(gr, user) returns.update({"members": [self._construct_member_info(pr) for pr in members]}) db_session.commit() return dumps((True, returns))
def get_count_like(keyword): start_time = time.time() #count = LogEntry.query.filter(LogEntry.referrer == "%" + keyword + "%").count() count = db_session.query(LogEntry).filter(LogEntry.destination.like( "%" + keyword + "%")).count() print("-- %s seconds --" % (time.time() - start_time)) return count
def getPropertyOptions(self): """ 如果是有序变量或名称变量,则获取其可取数值列表 @return list """ if self.typeOptions(): return db_session.query(PropertyOptions).filter(PropertyOptions.p_id==self.id).all()
def handleDeletePropertyForProject(self): """ 删除指定的研究项目属性 :return: """ _id, = self.postParams("id") if self.checkParamsAvailable(_id): try: _del_property = db_session.query(ProjectProperty).filter(ProjectProperty.id==_id).first() if _del_property is not None: db_session.query(ProjectItem.proj_id==_del_property.p_id).filter(ProjectItem.label==_del_property.label).delete() db_session.delete(_del_property) db_session.commit() self.changeResponse2Success() except Exception as e: db_session.rollback() self.setFailureReason(str(e))
def log_last_scraped(self): try: try: last_book_id = db_session.query(Book).order_by(Book.book_id.desc()).first() if last_book_id is not None: setting = db_session.query(Setting).filter(Setting.bit == 0).one() setting.book_last_id = last_book_id.book_id setting.book_last_ran = cutil.get_datetime() db_session.add(setting) db_session.commit() except NoResultFound: # If there is no raw data then no books were collected pass except: logger.exception("Problem logging last book scraped")
def get_active_pr(user): q = db_session.query(PersonalRecord ).filter(PersonalRecord.active==True ).filter(PersonalRecord.user_id==user.id) try: return q.one() except NoResultFound: return None
def get_code_snippets(code_id): if code_id: try: result = db_session.query(CodeSnippets).filter(CodeSnippets.code_id==code_id).one() return result except DisconnectionError: result = {'error': True, 'msg': 'Please try after some time'} return result
def _get_rnp(self): q = db_session.query(RoomNumberPool ).filter(RoomNumberPool.id==1 ) try: return q.one() except NoResultFound: return None
def handleVeiwQueryGeoPointGroup(self): """ 查询地理坐标集合 :return: """ gid, = self.getParams("gid") if self.checkParamsAvailable(gid): geo_point_group = db_session.query(GeoPointGroup).filter(GeoPointGroup.id==gid).first() if geo_point_group is not None: geo_point_units = db_session.query(GeoPointUnit).filter(GeoPointUnit.group_id==gid).all() self.setData({ 'gid': gid, 'geo_point_group': geo_point_group, 'geo_point_units': geo_point_units }) self.changeResponse2Success() else: self.setFailureReason("要查找的地理点位集合不存在!")
def handleLoadPropertyOptionsOfProperty(self): """ 获取指定属性下的所有属性选项 :return: """ pid, = self.postParams("pid") if self.checkParamsAvailable(pid): property = db_session.query(ProjectProperty).filter(ProjectProperty.id==pid).first() if property is not None: ret_data = {} options_list = db_session.query(PropertyOptions).filter(PropertyOptions.p_id==pid).all() ret_data.setdefault('property', property) ret_data.setdefault('options', options_list) self.setData(ret_data) self.changeResponse2Success() else: self.setFailureReason("字段属性不存在!")
def loadPropertyItem(self): ''' 获取项目字段属性 :param prop_id: :return: ''' prop_id, = self.postParams("prop_id") if self.checkParamsAvailable(prop_id): return db_session.query(ProjectProperty).filter(ProjectProperty.id==prop_id).first()
def order_product_grid(user_id,order_id, page=None, records_per_page=None): query = db_session.query(OrderProduct, Order, Product).join(Order).join(Product).filter(Order.id==order_id).\ filter(Order.user_id==user_id).filter((Order.status_id == 3)|(Order.status_id == 4)) count = query.filter_by(is_deleted=False).count() if page and records_per_page: stop = page * records_per_page start = stop - records_per_page return query.slice(start, stop).all(), count else: return query.all(),count