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()))
