def update_volume_with_email_passwd(models, email=None, passwd=None): session = Session() #kwdict = getvolume(models, email, passwd) if not hasattr(update_volume_with_email_passwd, 'ks'): setattr(update_volume_with_email_passwd, 'ks', KeywordSearch()) ks = update_volume_with_email_passwd.ks kwdict = ks.search(models) for k, v in kwdict.items(): print k, v m = session.query(Model).filter_by(model=k).first() if m: m.global_volume = volume2int(v[0]) m.local_volume = volume2int(v[1]) m.updated_at = datetime.utcnow() session.add(m) session.commit() session.close() sleep = 3 while sleep>0: import time print 'sleeping', sleep time.sleep(1) sleep -= 1
def post(self): md5 = hashlib.md5() register_name = self.get_argument('register_name') email = self.get_argument('email') passwd = self.get_argument('password') checking_password = self.get_argument('checking_password') # request_data = json.loads(body) # print(request_data) # register_name = request_data.get('register_name') # passwd = request_data.get('password') # checking_password = request_data.get('checking_password') # email = request_data.get('email') if passwd != checking_password: # 错误处理函数 pass md5.update(passwd.encode('utf-8')) hash_password = md5.hexdigest() new_user = User(register_name=register_name, passwd=hash_password, email=email) session = Session() session.add(new_user) try: session.commit() self.write('register successful') self.redirect('/login') except: session.rollback() #抛出异常 self.write('register failure')
def post(self, **kwargs): parser = reqparse.RequestParser() parser.add_argument('agency') parser.add_argument('doc_type') parser.add_argument('setaside') parser.add_argument('base_number') parser.add_argument('program_name') args = parser.parse_args() agency = args['agency'].decode('latin-1').encode('utf8') doc_type = args['doc_type'].decode('latin-1').encode('utf8') program_name = args['program_name'].decode('latin-1').encode('utf8') setaside = args['setaside'].decode('latin-1').encode('utf8') base_number = args['base_number'].decode('latin-1').encode('utf8') rfq = RFQ(agency=agency, doc_type=doc_type, program_name=program_name, setaside=setaside, base_number=base_number) session = Session() session.add(rfq) session.commit() return jsonify({'id': rfq.id})
def create_cocktail_mary_post(): user = Session.query(User).filter(User.username == 'Fat Larry').first() category = (Session.query(Category).filter( Category.name == 'Коктейли').one_or_none()) receipt_text = '''Налить водку и томатный сок в охлаждённый высокий стакан. Добавить лимонный сок. После по вкусу насыпать перец и соль. Всё тщательно перемешать и украсить веточкой сельдерея, можно долькой лимона. ''' receipt = Receipt( user_id=user.id, category_id=category.id, title='Коктейль Кровавая Мэри', text=receipt_text, is_published=True, category=category, picture='mary.jpg', picture_min='mary-small.jpg', ) ingredients = [ ('водка', 'охлаждённая', 75, 'мл'), ('томатный сок', '', 100, 'мл'), ] for item in ingredients: ingredient = Session.query(Ingredient).filter( Ingredient.name == item[0]).first() a = IngredientsAssociation(correction=item[1], quantity=item[2], measure=item[3]) a.ingredient = ingredient receipt.ingredients.append(a) Session.flush() Session.add(receipt) Session.commit()
def rps(ts_code, date, days=120): ''' 计算RPS值 ''' date = convert_date(date) if CACHE: session = Session() record = session.query(Rps).filter_by(code=ts_code, date=date, days=days).first() if record is not None: session.close() return record.value result = 0 sorted_list, codes_count = extrs_sorted_list(date, days=days) ex = extrs(ts_code, date, days=days) if not (ex is None or ex not in sorted_list): location = sorted_list.index(ex) location = location + 1 result = (1 - location / codes_count) * 100 if CACHE: record = Rps(code=ts_code, date=date, days=days, value=result) session.add(record) session.commit() session.close() return result
def post(self, rfq_id): data = request.get_json()["data"] row1 = data['row1'] row2 = data['row2'] row3a = data['row3a'] row3b = data['row3b'] row4a = data['row4a'] row4b = data['row4b'] row5a = data['row5a'] row5b = data['row5b'] row6a = data['row6a'] row6b = data['row6b'] additional_clin = AdditionalClin(document_id=int(rfq_id), row1=row1, row2=row2, row3a=row3a, row3b=row3b, row4a=row4a, row4b=row4b, row5a=row5a, row5b=row5b, row6a=row6a, row6b=row6b) session = Session() session.add(additional_clin) session.commit() clins = session.query(AdditionalClin).filter_by( document_id=rfq_id).all() return jsonify(data=[c.to_dict() for c in clins])
def makefriend(request): login = authenticated_userid(request) if(login!= None): parsed = urlparse.urlparse(request.referer) friendid = int(urlparse.parse_qs(parsed.query)['id'][0]) DBSession = Session(bind=engine) user = DBSession.query(User).filter(User.login == login).one() friendrequest = DBSession.query(Friendrequest).filter(and_(Friendrequest.user_to_id == user.id,Friendrequest.user_from_id == friendid)).all() #принимаем заявку в друзья if (len(friendrequest) > 0): messageFile = "{0}-{1}.txt".format(user.id, friendid) messageLocPath = "socialnetwork/static/" +messageFile with open(messageLocPath,'w') as f: f.write('') friendship = Friendship(user_from_id = friendid, user_to_id = user.id, dialogLocPath = messageLocPath) DBSession.add(friendship) DBSession.delete(friendrequest[0]) DBSession.commit() else: #запрос от текущего аккаунта выбранному пользователю friendrequest = DBSession.query(Friendrequest).filter(and_(Friendrequest.user_to_id == friendid,Friendrequest.user_from_id == user.id)).all() #добавление, если нет еще запроса if (len(friendrequest) == 0 ): friendrequest = Friendrequest(user_from_id = user.id, user_to_id = friendid) DBSession.add(friendrequest) DBSession.commit() return HTTPFound(location=request.referer) return HTTPFound(location='/')
def user_answer(): user_id = int(session_f['user_id']) lesson_id = request.form.get('lesson_id') has_access = check_user_access(user_id, lesson_id) if has_access: question_id = request.form.get('question_id') ans_no = request.form.get('ans_no') question_type = request.form.get('question_type') s = Session() user_previous_answer = s.query(User_answer.id).filter(User_answer.user_id == user_id, User_answer.question_id == question_id).first() if not user_previous_answer : user_answer = User_answer(ans_no=ans_no, user_id = user_id, question_id=question_id, lesson_id=lesson_id) s.add(user_answer) s.commit() else: user_answer_update = s.query(User_answer).filter(User_answer.id == user_previous_answer[0]).update({User_answer.ans_no : ans_no}) s.commit() user_question_ids = s.query(Enrol_user.question_ids).filter(Enrol_user.lesson_id == lesson_id, Enrol_user.user_id == user_id).first() if user_question_ids[0] != 'na': complete_user_question_ids = user_question_ids[0] + ',' + str(question_id) user_question_ids_len = len(user_question_ids[0].split(',')) else: complete_user_question_ids = str(question_id) user_question_ids_len = 1 questions_len = s.query(Question).filter(Question.lesson_id == lesson_id).count() next_content = None if question_type == 'new_questions': next_content = False complete_question = 'True' if user_question_ids_len + 1 < questions_len: next_content = True complete_question = 'False' return_url = f'/new-questions/{lesson_id}' s.query(Enrol_user).filter(Enrol_user.lesson_id == lesson_id, Enrol_user.user_id == user_id).update({ Enrol_user.complete_question: complete_question, Enrol_user.question_ids : complete_user_question_ids}) s.commit() elif question_type == 'continue_questions': complete_question = 'True' if user_question_ids_len + 1 < questions_len: next_content = True complete_question = 'False' return_url = f'/continue-questions/{lesson_id}' s.query(Enrol_user).filter(Enrol_user.lesson_id == lesson_id, Enrol_user.user_id == user_id).update({ Enrol_user.complete_question: complete_question , Enrol_user.question_ids : complete_user_question_ids}) s.commit() else: next_content = s.query(User_answer).order_by(User_answer.question_id.asc()).filter(User_answer.user_id == user_id, User_answer.question_id> question_id, User_answer.ans_no == '1', User_answer.lesson_id == lesson_id).first() if next_content: return_url = f'/wrong-questions/{lesson_id}/{question_id}' if next_content: result = {'has_next_new_question': "True", "return_url" : return_url} else: wrong_answer_no = s.query(func.count(User_answer.id)).order_by(User_answer.lesson_id).filter(User_answer.user_id == user_id ,User_answer.ans_no == '1', User_answer.lesson_id == lesson_id).scalar() true_answer_no = s.query(func.count(User_answer.id)).order_by(User_answer.lesson_id).filter(User_answer.user_id == user_id, User_answer.ans_no == '0', User_answer.lesson_id == lesson_id).scalar() result = {"has_next_new_question":"False", "wrong_answer_no":wrong_answer_no, "true_answer_no":true_answer_no} s.commit() s.close() else: #flash('این درس برای شما باز نشده است!','danger') #return redirect(url_for("grades")) result = {'has_next_new_question': "True", "return_url" : None} return jsonify(result)
def update_database(product_data, variation_data): database_data = { 'sku': variation_data['sku'], 'wishsku': variation_data['sku'], 'wishid': variation_data['wishid'], 'wishparentsku': variation_data['parent_sku'], 'wish_quantity': variation_data['inventory'], 'on_wish': 1 } # sku is the kkk session = Session() sku = database_data['sku'] result = session.query(WishTracking).filter_by(sku=sku).first() if result: print 'updated record', database_data['sku'] # we found this so update it result = session.query(WishTracking).filter_by( sku=sku).update(database_data) session.commit() else: print 'inserted new record', database_data['sku'] session.add(WishTracking(**database_data)) session.commit() session.close()
def update_local_questions(remote_questions): session = Session() local_questions = session.query(Question).all() local_questions_map = _get_questions_id_map(local_questions) remote_questions_map = _get_questions_id_map(remote_questions) # insert or update questions for q in remote_questions: local_question = local_questions_map.get(q.id) if (local_question): local_question.question = q.question local_question.option_a = q.option_a local_question.option_b = q.option_b local_question.priority = q.priority local_question.created_at = q.created_at local_question.count_a = q.count_a local_question.count_b = q.count_b else: session.add(q) # remove questions deleted from server for q in local_questions: if (not remote_questions_map.get(q.id)): session.delete(q) session.commit()
def train_all(instrument_filename, day_file_path, result_file_path): #instruments = pd.read_csv(instrument_filename, index_col=False, dtype={'code': object}) instruments = ts.get_stock_basics() if instruments is None: print("Could not find any instruments, exit") return instruments.sort_index(inplace=True) #instruments.reset_index(inplace=True) session = Session() session.query(StockPrediction).delete() session.commit() for index, row in instruments.iterrows(): try: rate = train(index, day_file_path=day_file_path, result_file_path=result_file_path) item = StockPrediction(index, name=row['name'], accu_rate=rate) session.add(item) session.commit() except: print("%s compute failure" % index) continue session.close()
def create_comments_for_receipts(): user = Session.query(User).filter(User.username == 'Fat Larry').first() receipt = Session.query(Receipt).filter( Receipt.title == 'Курица с овощами').one_or_none() comment = Comment(user=user, receipt=receipt, text='Very nice, Bro!') Session.add(comment) Session.commit()
def buildUrl(): "生成短网址" url = request.form.get("url", None) token = hashlib.md5(url).hexdigest() dbSession = Session() query = dbSession.query(UrlModel) obj = query.filter(UrlModel.token == token).first() if obj == None: obj = UrlModel(token, url) dbSession.add(obj) dbSession.commit() key = obj.id else: key = obj.id dbSession.close() key = str(hex(key))[2:] key = key[:len(key) - 1] key = "http://" + request.headers['host'] + "/shortUrl/s/" + key response = make_response(json.dumps({"key": key})) response.headers['Content-Type'] = "application/json" return response
def snapshot(self, date=None): ''' 记录某一时刻的股票情况 ''' try: session = Session() date = self.convert_date(date) stocks = [] stocks_df = self.get_profile_stocks_df_thru_date(date, type='close') for index, row in stocks_df.iterrows(): stock_d = self.convert_date(row['date']) stock_d = None if stock_d is None else stock_d.strftime('%Y-%m-%d') stocks.append({'code': self.convert_to_py_type(row['code']), 'price': self.convert_to_py_type(row['price']), 'trade_price': self.convert_to_py_type(row['trade_price']), 'date': stock_d, 'count': self.convert_to_py_type(row['count']), 'account': self.convert_to_py_type(row['account'])}) record = self.get_profile_list_class()(money=self.convert_to_py_type(self.get_money()), profile_account=self.convert_to_py_type(self.get_profile_account_thru_date(date, type='close')), date=date, stocks=stocks) session.add(record) session.commit() except Exception as e: print("%s"%(str(e))) session.rollback() finally: session.close()
def main(): session = Session() for idx, rotten_movie in enumerate( session.query(RottenMovie).filter( RottenMovie.amazon_movie_id.is_(None), RottenMovie.affiliate_amazon_valid.is_(True), )): # if rotten_movie.id < 1623: # continue m = re.search('^http://www.amazon.com/gp/product/(?P<path>.*)$', rotten_movie.affiliate_amazon_url) if not m: assert re.search('^http://www.amazon.com/gp/video/primesignup', rotten_movie.affiliate_amazon_url) continue url = '/{}'.format(m.group('path')) print('>>', rotten_movie.id, url) amazon_movie = session.query(AmazonMovie).filter_by(url=url).first() if amazon_movie is None: amazon_movie = AmazonMovie(url=url) session.add(amazon_movie) rotten_movie.amazon_movie = amazon_movie if idx % 100 == 0: session.commit() session.commit()
def create_comment(comment: Comment) -> None: Session.add(comment) try: Session.commit() except Exception as e: Session.rollback() raise InternalServerError(f"Could not create comment! Error: {e}")
def buildUrl(): "生成短网址" url = request.form.get("url",None) token=hashlib.md5(url).hexdigest() dbSession=Session() query=dbSession.query(UrlModel) obj=query.filter(UrlModel.token == token).first() if obj == None: obj = UrlModel(token,url) dbSession.add(obj) dbSession.commit() key = obj.id else: key = obj.id dbSession.close() key=str(hex(key))[2:] key=key[:len(key)-1] key="http://"+request.headers['host']+"/shortUrl/s/"+key response = make_response(json.dumps({"key":key})) response.headers['Content-Type']="application/json" return response
def update_likes(campaign_id, api): kill_firefox_and_xvfb() session = Session() campaign = session.query(Campaign).get(campaign_id) user = session.query(User).get(campaign.user.id) downloaded_results = downloads(session, campaign, api) prospect_array = [] prospects = ProspectProfile.get_unliked_requests(session, campaign.id, 50) for prospect in prospects: prospect.done = True session.commit() prospect_array.append(prospect.prospect.username) ig = InstagramBot( username=user.username, password=user.password, prospects=prospect_array) result = ig.like() for k, v in result.iteritems(): prospect = session.query(Prospect).filter_by(username=k).first() if prospect: user_like = UserLike(user=user, prospect=prospect, media_id=v) session.add(user_like) session.commit() campaign.generate_stats(session, total_likes=ig.completed) campaign = session.query(Campaign).get(campaign_id) if campaign.job_id: result = update_likes.apply_async(countdown=1000, args=(campaign.id, api,)) print "old", campaign.job_id campaign.job_id=result.id session.commit() print "new", campaign.job_id else: print "no longer doing this" return True
def post(self): username = self.get_argument('username') item_id = self.get_argument('item_id') try: file1 = self.request.files['file'][0] except: file1 = None final_string = '' session = Session() try: user = dbutils.get_or_create(session, User, username=username) item = dbutils.get_or_create(session, Item, item_id=item_id) item_completion = dbutils.get_or_create(session, ItemCompletion, item_id=item.id, user_id=user.id) if file1 is not None: original_fname = file1['filename'] extension = os.path.splitext(original_fname)[1] final_filename = item_id + extension if not os.path.exists("./uploads"): os.makedirs("./uploads") if not os.path.exists("./uploads/%s" % username): os.makedirs("./uploads/%s" % username) output_file = open("./uploads/" + username + "/" + final_filename, 'wb') output_file.write(file1['body']) item_completion.file_path = "uploads/" + username + "/" + final_filename session.add(item_completion) session.commit() final_string = "You have crossed item " + item_id + " off your bucket list!" except Exception, e: session.rollback() logger.exception(e) final_string = "Oops! Something went wrong. Please try again"
def __make_pots_thread(self): db_session = Session() while not self._exit_flag: if self.evil_task_queue.empty(): time.sleep(5) evil_ip = self.evil_task_queue.get() logger.info("Get An Evil IP: {0}".format(evil_ip)) for ip in evil_ip: # 检查这个attacker ip是不是已经绑定了蜜罐了 qs = db_session.query(KokkuriSSHPot).filter( KokkuriSSHPot.attacker_ip == ip).first() if qs: continue container_name = "{0}_honeypot".format(ip.replace(".", "_")) container_id, ssh_port = self.docker_pot.create_container( container_name) qs = KokkuriSSHPot(container_name=container_name, container_id=container_id, pot_ip=server_config.HONEYPOT_IP, attacker_ip=ip, ssh_port=ssh_port, status=1) db_session.add(qs) db_session.commit()
def make_app(): # TODO: this is temporary code to initialize the available models session = Session() try: f = open('wood_berry.pkl', 'rb') pickled_model = pickle.load(f) session.add( Model(name='Wood-Berry Distillation', system=pickled_model.system, inputs=pickled_model.inputs, outputs=pickled_model.outputs)) session.commit() except: session.rollback() raise finally: f.close() session.close() return tornado.web.Application([(r'/', MainHandler), (r'/models/all/?', ModelListHandler), (r'/models/(\d+)/?', ModelCreateHandler), (r'/sims/all/?', SimulationListHandler), (r'/sims/(\d+)/?', SimulationGetHandler), (r'/sims/(\d+)/(\d+)/?', TagGetHandler), (r'/([0-9a-f\-]+)', WebSocketHandler)])
def join_room(secure_channel, request): ''' 加入聊天室 ''' username = secure_channel_to_username[secure_channel] room_name = request.strip() result = {'success': False, 'message': ''} session = Session() room = session.query(ChatRoom).\ filter(ChatRoom.room_name == room_name).first() if not room: result['message'] = '聊天室不存在!' secure_channel.send(Command.JOIN_ROOM_RESULT, result) return roomuser = session.query(RoomUser).\ filter(RoomUser.roomname == room_name, RoomUser.username == username).\ first() if roomuser: result['message'] = '已经在聊天室中!' secure_channel.send(Command.JOIN_ROOM_RESULT, result) return roomuser = RoomUser(roomname=room_name, username=username) session.add(roomuser) session.commit() secure_channel.send(Command.ON_NEW_ROOM, room_name)
class Post(bourbon.ModelInterface): @staticmethod def all(): sess = Session() return [post.id for post in sess.query(PostModel).all()] @staticmethod def open(identifier): self = Post() self.sess = Session() self.post = self.sess.query(PostModel).filter_by(id=identifier).scalar() if self.post is None: self.post = PostModel() return self @staticmethod def stat(identifier): post = Post.open(identifier) return bourbon.Stat.as_file(len(post.read())).as_dict() def close(self): self.sess.add(self.post) self.sess.commit() del self.sess del self.post return True def read(self): return self.post.text def write(self, data): self.post.text = data def getattr(self): return bourbon.FILE
def server_rebuild(): test_id = request.args.get('test_id') if not request.json: abort(401) server_name = request.json['server'] image_name = request.json['image'] sess = _create_session(int(test_id)) nova = nova_cli.Client('2.1', session=sess) servers = nova.servers.list(search_opts={"name": server_name}) glance = glance_cli.Client('2', session=sess) images = list(glance.images.list(filters={"name": image_name})) if servers and len(servers) and images and len(images): server = servers[0] image = images[0] db = Session() image_dao = _image_dao_create(db, image, test_id, True) server_dao = db.query(OSServer).filter( OSServer.uid == server.id).first() if not server_dao: abort(404) server_dao.image = image_dao server.rebuild(image) db.add(server_dao) db.commit() return jsonify(success=True) else: abort(401)
def __check_one_proxy(self): session = Session() proxy = self.queue.get() proxy = check_proxy(proxy) if proxy.speed == -1: proxy.score['power'] += 1 proxy.score['score'] -= proxy.score['power'] session.add(proxy) logger.info('decrease: {}:{} score from {} to {}!'.format( proxy.ip, proxy.port, proxy.score['score'] + proxy.score['power'], proxy.score['score'])) if proxy.score['score'] <= 0: session.delete( session.query(Proxy).filter(Proxy.ip == proxy.ip).first()) logger.warning(f'delete: {proxy.ip}:{proxy.port} score 0!') else: proxy.score['power'] = 0 if not proxy.score['score'] == settings.MAX_SCORE: # 如果代理可用就将该代理的分数增加到最大 proxy.score['score'] = settings.MAX_SCORE logger.info( f'update: {proxy.ip}:{proxy.port}, to max score successfully!' ) session.commit() session.close() self.queue.task_done()
def write_to_db(clusters, section): session = Session() session.query(StockCluster).filter( StockCluster.section == section).delete() session.query(StockClusterItem).filter( StockClusterItem.section == section).delete() for cluster in clusters.items: for code in cluster.stocks: stock_cluster_item = StockClusterItem( section=section, parent_code=cluster.code, code=code, name=cluster.stocks[code].name, corr=cluster.stocks[code].corr) session.add(stock_cluster_item) stock_cluster = StockCluster(section=section, code=cluster.code, name=cluster.name) session.add(stock_cluster) session.commit() session.close()
def create_user(user: User) -> None: Session.add(user) try: Session.commit() except Exception as e: Session.rollback() raise InternalServerError(f"Could not create user! Error: {e}")
def CREATE_ROOM(secure_channel, request): roomname = request['roomname'].strip() members = request['members'] session = Session() result = {'success': False, 'message': ''} room = session.query(ChatRoom).\ filter(ChatRoom.room_name == roomname).\ first() if room: result['message'] = '聊天室已存在!' secure_channel.send(Command.CREATE_ROOM_RESULTT, result) return room = ChatRoom(room_name=roomname) session.add(room) session.commit() for member_name in members: member = session.query(User).\ filter(User.username == member_name).count() if member: roomuser = RoomUser(roomname=roomname, username=member_name) session.add(roomuser) session.commit() if member_name in username_to_secure_channel: username_to_secure_channel[member_name].\ send(Command.ON_NEW_ROOM, roomname)
def process_notification(): session = Session() tg_chat_id = config.get("telegram_chat_id") subq = session.query(PushRecord) \ .filter_by(telegram_chat_id=tg_chat_id).subquery() new_announcements = session.query(Announcement).filter_by(present=True) \ .outerjoin(subq, Announcement.id == subq.c.announcement_id) \ .filter(subq.c.id is None).all() new_announcements = new_announcements[::-1] # Push old announcemt first if not len(new_announcements): return print("Sending {} notification(s)...".format(len(new_announcements))) for anno in new_announcements: try: session = Session() push_telegram_notification(anno, tg_chat_id) session.add(PushRecord(announcement_id=anno.id, telegram_chat_id=tg_chat_id)) session.commit() except Exception: session.rollback() print("Done!")
def post(self): username = self.get_argument('username') game_id = self.get_argument('game_id') dispute_id = self.get_argument('dispute_id') shot_upheld = self.get_argument('dispute_upheld') gm_decision_reason = self.get_argument('gm_decision_reason') session = Session() try: dispute = session.query(Dispute).filter_by(id=dispute_id).one() shot = session.query(Shot).filter_by(id=dispute.shot_id).one() resolving_user = get_user(username=username) game = get_game(game_id) mission = get_mission(game_id=game_id, assassin_id=shot.assassin_id, target_id=shot.target_id, completed_timestamp=None) if resolving_user in game.game_masters: if shot_upheld == 'True': game.mission_completed(mission) dispute.shot_upheld = True else: dispute.shot_upheld = False target_usergame = get_usergame(shot.target_id, game.id) if target_usergame.alive == None: target_usergame.alive = True session.add(target_usergame) dispute.gm_decision_reason = gm_decision_reason session.add(dispute) session.flush() session.commit() response_dict = get_response_dict(True) else: response_dict = get_response_dict(False, 'Only the game master can resolve a dispute') except Exception, e: session.rollback() response_dict = get_response_dict(False, e.message)
def post(self): shot_id = self.get_argument('shot_id') username = self.get_argument('username') shot_upheld = self.get_argument('shot_upheld') claim = self.get_argument('claim', '') try: resolving_user = get_user(username=username) shot = get_shot(shot_id) game = get_game(shot.game_id) session = Session() mission = get_mission(game_id=game.id, assassin_id=shot.assassin_id, target_id=shot.target_id, completed_timestamp=None) if shot_upheld == 'True': if shot.target_id == resolving_user.id or resolving_user in game.game_masters: shot.kill_upheld = True game.mission_completed(mission, shot) response_dict = get_response_dict(True) else: if shot.target_id == resolving_user.id: dispute = Dispute(game.id, shot_id, claim) session.add(dispute) session.flush() session.commit() response_dict = get_response_dict(True) elif resolving_user in game.game_masters: shot.kill_upheld = False response_dict = get_response_dict(True) except Exception as e: session.rollback() response_dict = get_response_dict(False, e.message) finally: Session.remove() self.finish(simplejson.dumps(response_dict))
def signin(): if 'username' not in request.form or 'secret' not in request.form or 'openport' not in request.form: return "\"POST request must contain 'openport', 'username' and 'secret' fields\"" session = Session() username = request.form['username'] secret = request.form['secret'] openport = int(request.form['openport']) users = session.query(User).filter(User.id == username).all() if (len(users) == 0): now = datetime.datetime.now() user = User(id=username, secret = secret, lastping = now, lastip=request.remote_addr, lastport = openport) session.add(user) session.commit() session.close() return json.dumps("True") else: if users[0].secret == secret: users[0].lastip = request.remote_addr users[0].lastport = openport users[0].lastping = datetime.datetime.now() session.add(users[0]) for ownership in session.query(Owner).filter(Owner.owner == username).all(): session.delete(ownership) session.commit() session.close() return json.dumps(True) else: return json.dumps(False)
def add_task(self, project_name, spider_name): session = Session() project = session.query(Project).filter( Project.name == project_name).first() spider = session.query(Spider).filter( Spider.name == spider_name, Spider.project_id == project.id).first() try: existing = list( session.query(SpiderExecutionQueue).filter( SpiderExecutionQueue.spider_id == spider.id, SpiderExecutionQueue.status.in_([0, 1]))) if existing: logger.warning('job %s_%s is running, ignoring schedule' % (project.name, spider.name)) raise JobRunning(existing[0].id) executing = SpiderExecutionQueue() jobid = generate_job_id() executing.id = jobid executing.spider_id = spider.id executing.project_name = project.name executing.spider_name = spider.name executing.fire_time = datetime.datetime.now() executing.update_time = datetime.datetime.now() session.add(executing) session.commit() session.refresh(executing) return executing finally: session.close()
def register(): if 'username' not in request.form or 'filename' not in request.form or 'hash' not in request.form or 'size' not in request.form: return "\"POST request must contain 'username', 'filename', 'size', and 'hash'.\"" session = Session() username = request.form['username'] filename = request.form['filename'] md5 = request.form['hash'] size = request.form['size'] files = session.query(File).filter(File.filename == filename).filter(File.md5 == md5) files = files.all() if len(files) == 0: f = File(filename= filename, md5 = md5, filesize = size) session.add(f) session.commit() else: f = files[0] fileid = f.id if 'path' in request.form: loc = request.form['path'] else: loc = filename print username, filename, md5, loc if not session.query(Owner).filter(Owner.owner == username).filter(Owner.dirpath == loc).filter(Owner.fileid == fileid).all(): session.add(Owner(owner = username, dirpath = loc, fileid = fileid)) session.commit() session.close() return json.dumps(True)
def init(self): session = Session() # move completed jobs into history for job in session.query(SpiderExecutionQueue).filter( SpiderExecutionQueue.status.in_((2, 3))): historical_job = HistoricalJob() historical_job.id = job.id historical_job.spider_id = job.spider_id historical_job.project_name = job.project_name historical_job.spider_name = job.spider_name historical_job.fire_time = job.fire_time historical_job.start_time = job.start_time historical_job.complete_time = job.update_time historical_job.status = job.status session.delete(job) session.add(historical_job) session.commit() # init triggers triggers = session.query(Trigger) for trigger in triggers: try: self.add_job(trigger.id, trigger.cron_pattern) except InvalidCronExpression: logger.warning('Trigger %d,%s cannot be added ' % (trigger.id, trigger.cron_pattern)) session.close() self.scheduler.start() self.poll_task_queue_callback.start() self.clear_finished_jobs_callback.start() self.reset_timeout_job_callback.start()
def create_entry(model_class, *, commit=True, **kwargs): session = Session() entry = model_class(**kwargs) session.add(entry) if commit: session.commit() return entry
def register(): if session_f.get("login") == True: return redirect(url_for("grades")) if request.method == "POST": s = Session() mobile = request.form.get('mobile') user = s.query(User).filter(User.mobile == mobile).first() if user == None : full_name = request.form.get('name') password = request.form.get('pass') hash_password = make_hashed_password(password) user = User(full_name = full_name, mobile =mobile, password = hash_password) s.add(user) s.commit() session_f['user_id'] = user.id session_f['login'] = True session_f.permanent = True flash(f'{user.full_name} عزیز شما با موفقیت ثبت نام شدید.','success') s.close() return redirect(url_for("grades")) else: flash('کاربر عزیز، با این شماره موبایل قبلا ثبت نام شده، در صورت فراموشی رمز "فراموشی کلمه عبور" را لمس نمایید. ','danger') s.commit() s.close() return redirect(url_for("login")) return render_template('signup.html')
def server_resize(): test_id = request.args.get('test_id') if not request.json: abort(401) flavor_name = request.json['flavor'] server_name = request.json['server'] sess = _create_session(int(test_id)) nova = nova_cli.Client('2.1', session=sess) flavor = nova.flavors.find(name=flavor_name) servers = nova.servers.list(search_opts={"name": server_name}) if flavor and servers and len(servers): server = servers[0] if server.flavor['id'] == flavor.id: abort(401) else: server.resize(flavor=flavor.id) db = Session() server_dao = db.query(OSServer).filter( OSServer.uid == server.id).first() flavor_dao = db.query(OSFlavor).filter( OSFlavor.uid == flavor.id).first() _create_test_log( db, test_id, 'Server %s RESIZE %s' % (repr(server_dao), repr(flavor_dao))) server_dao.flavor_alt = server_dao.flavor server_dao.flavor = flavor_dao db.add(server_dao) db.commit() return jsonify(success=True), 201 else: abort(404)
def resolve_friend_request(secure_channel, request): ''' 处理好友请求 ''' to_user = secure_channel_to_username[secure_channel] from_user = request['username'] accepted = request['accepted'] session = Session() if _is_friend(session, from_user, to_user): pass else: friend = session.query(Friend).\ filter(Friend.from_user == from_user, Friend.to_user == to_user, Friend.accepted == False).first() if accepted: friend.accepted = True session.add(friend) session.commit() secure_channel.send(Command.NEW_CONTACT, from_user) if from_user in username_to_secure_channel: username_to_secure_channel[from_user].\ send(Command.NEW_CONTACT, to_user) else: session.delete(friend) session.commit()
def main(): session = Session() for idx, amazon_movie in enumerate( session.query(AmazonMovie).filter( AmazonMovie.web_page_id.is_(None))): # time.sleep(1) # if amazon_movie.id < 1623: # continue print( '>>', '{:4d}'.format(amazon_movie.id), ) if not amazon_movie.url: continue web_page = WebPage() session.add(web_page) amazon_movie.web_page = web_page session.commit() success = _request_and_save(web_page.key, amazon_movie.url) if not success: session.delete(web_page) amazon_movie.web_page = None session.commit() print(' [-] Fail') else: print(' [+] Success')
def add_feed_to_db(): feed_url = request.args["feed_url"] feed = RSSFeed(current_user.id, feed_url) session = Session() session.add(feed) session.commit() return redirect(url_for('dashboard'))
def create_tables(): Base.metadata.create_all(engine) session = Session() for agency in agencies: a = Agency(abbreviation=agency, full_name=agencies[agency]) session.add(a) session.commit()
def run_image(app_image_id): db = Session() app_image = db.query(AppImage).get(app_image_id) f = app_image.app.app_type() container_id = f.run(app_image.app.id, app_image.docker_image_id) instance = AppInstance(app_image=app_image, container_id=container_id) db.add(instance) db.commit()
def add_github_repo_to_db(): gh_user = request.args["github_user"] gh_url = request.args["github_url"] repo = GithubRepo(current_user.id, gh_user, gh_url) session = Session() session.add(repo) session.commit() return redirect(url_for('dashboard'))
def load_fixtures(): session = Session() try: for model, items in fixtures.items(): for item in items: session.add(model(**item)) session.commit() except: session.rollback()
def create_question(): data = flask.request.json s = Session() question = Question(quiz_id = data['quiz_id'], title = data['title']) s.add(question) s.commit() return flask.jsonify({'quiz_id': data['quiz_id'], 'title': data['title']})
def _part_cleanse(offset, limit): print offset, limit session = Session() for p in session.query(Product).filter_by(level=-1).offset(offset).limit(limit): level = getlevel(p.model) if p.level != level: print p.model, p.site, p.title, level p.level = level session.add(p) session.commit()
class TestDay(object): def setUp(): self.session = Session() def tearDown(): del self.session def test_day_creation(): d = Day(date.today()) self.session.add(d) self.session.commit() assert d.id != None
def save_audio(words, speaker_id, audio_file): for word, start, end in words: # Get or create word word_obj = Session.query(Word).filter_by(word=word).first() if not word_obj: word_obj = Word(word=word) Session.add(word_obj) # Add audio Session.add(Audio(word=word_obj.word, audio_file=audio_file, start=start, end=end, speaker_id=speaker_id)) Session.commit() print("Saved {} audios ".format(len(words)), end="")
def create_quiz(): """ Requires email, title """ data = flask.request.json s = Session() _user_id = s.query(User.id).filter_by(email=data['email']).all()[0] quiz = Quiz(user_id = str(_user_id), title = data['title']) s.add(quiz) s.commit() return flask.jsonify({'email': data['email'], 'title': data['title']})
def post(self, **kwargs): args = parser.parse_args() agency = args["agency"] doc_type = args["doc_type"] setaside = args["setaside"] base_number = args["base_number"] print agency, doc_type, setaside, base_number rfq = RFQ(agency=agency, doc_type=doc_type, setaside=setaside, base_number=base_number) session = Session() session.add(rfq) session.commit() return jsonify({"id": "1"})
def add_comments(campaign_id): session = Session() campaign = session.query(Campaign).get(campaign_id) api = instagram.client.InstagramAPI(access_token=campaign.user.access_token) for prospect in campaign.prospect_profiles: print prospect.prospect.instagram_id media_id = find_media(api, prospect, campaign.comment) if media_id: prospect_comment = ProspectComment( media_id=media_id, prospect_profile=prospect ) session.add(prospect_comment) session.commit()
def set_or_create_assignment_asset_directory(parent_assignment, directory_dict, session=None): if session is None: session = Session() existing_dir = session.query(AssignmentAssetDirectory).get(directory_dict.get('id', -1)) if existing_dir is None: existing_dir = AssignmentAssetDirectory(**directory_dict) session.add(existing_dir) else: del directory_dict['id'] existing_dir.set_dict(**directory_dict) existing_dir.assignment_id = parent_assignment.id session.commit()
def get(self): item_id = self.get_argument('itemid') description = self.get_argument('description', '') session = Session() try: item = dbutils.get_or_create(session, Item, item_id=item_id) item.description = description session.add(item) session.flush() session.commit() finish_string = "Item added" # completed_items = session.Query(ItemCompletion).filter() except Exception, e: session.rollback() finish_string = "Item not added"
def make_event(request): creator_name = request.params['creator_name'] name = request.params['name'] description = request.params['description'] location = request.params['location'] e = Event(creator_name = creator_name, name = name, added = datetime.datetime.now(), description = description, location = location) Session.add(e) import transaction adminKey = e.admin_key transaction.commit() return HTTPFound(location="/sharelinks/{0}".format(adminKey))
def loadPhoto_view(request): login = authenticated_userid(request) if(login!= None): imageName = login+'Photo'+ str(datetime.datetime.now()) with open("socialnetwork/static/"+imageName,'wb') as f: f.write(request.params["myimg"].value) path = request.static_url('socialnetwork:static/'+imageName) DBSession = Session(bind=engine) user = DBSession.query(User).filter(User.login == login).one() photo = Photo(user_id = user.id, path = path) DBSession.add(photo) DBSession.commit() return HTTPFound(location='/photo') return HTTPFound(location='/')
def eomReceived(self): lines = self.lines split_index = lines.index('') msg = lines[split_index + 1] headers = [Header(*line.split(':', 1)) for line in lines[:split_index]] email = Email(headers=headers, received=datetime.now(), msg=msg) sn = Session() sn.add(email) sn.commit() self.lines = None return defer.succeed(None)
def registration_view(request): if (request.method == "POST"): name = request.params['name'] lastname = request.params['lastname'] login = request.params['login'] password = request.params['password'] if(name != '' and lastname != '' and login != '' and password != ''): DBSession = Session(bind=engine) users = DBSession.query(User).filter(User.login == login).all() if(len(users) == 0): avatar = request.static_url('socialnetwork:static/defaultAvatar.png') user = User(name = name, lastname = lastname,login = login, password = password,avatar = avatar) DBSession.add(user) DBSession.commit() return {'visibility':'visible', 'text' : u"Успешная регистрация!"} else: return {'visibility':'visible', 'text' : u"Такой логин уже занят"} else: return {'visibility':'visible', 'text' : u"Не все поля заполнены"} return {'visibility':'hidden', 'text': ''}
def twitter_verification(): twitter_key = request.cookies.get('twitter_key') twitter_secret = request.cookies.get('twitter_secret') config = json.load(open('config.json')) consumer_key = str(config["TwitterReader"]["CONSUMER_KEY"]) consumer_secret = str(config["TwitterReader"]["CONSUMER_SECRET"]) auth = tweepy.OAuthHandler(consumer_key, consumer_secret) auth.set_request_token(twitter_key, twitter_secret) auth.get_access_token(request.args["verification_code"]) oauthtoken = OAuthTokens() oauthtoken.twitter_key = auth.access_token.key oauthtoken.twitter_secret = auth.access_token.secret oauthtoken.user_id = current_user.id session = Session() session.add(oauthtoken) session.commit() return redirect(url_for('dashboard'))
def response(self): if self.request.method == 'POST': submitted = self.request.POST.items() try: self.get_form().validate(submitted) except deform.ValidationFailure as e: return Response( env.get_template('create.html').render(form=e.render())) article = Articles(**{'title': self.request.POST['title'], 'content': self.request.POST['content'] }) dbsession = Session() dbsession.add(article) dbsession.commit() dbsession.close() self.session = get_session(self.request).pop('csrf') return Response(status=302, location='/blog/') return Response(env.get_template('create.html') .render(form=self.get_form().render()))