def ran_script(script_id):
if request.args.get('secret') != API_SECRET:
abort(401)
event = Event.query.order_by(Event.id.desc()).first()
defending_team = AttendingTeam.query.filter_by(
id=request.args.get('team_id'), event=event).first()
error = int(request.args.get('error'))
error_msg = request.args.get('error_msg', None)
script = Script.query.filter_by(id=script_id).first()
if str(script.type).split(".")[-1] == "exploit":
abort(500)
return
script_run = ScriptRun()
script_run.script = script
script_run.attending_team = defending_team
script_run.error = error
if len(error_msg) > 2040:
script_run.error_msg = error_msg[:2040] + "<cut>" # XXX
else:
script_run.error_msg = error_msg
db_session.add(script_run)
db_session.commit()
return jsonify({"result": "great success"})
def add_expense(self, date, description, amount, category_id=None, account_id=None, pass_thru=False):
# add into uncategorized expenses if category not provided
if not category_id:
category_id = self.is_category(name="Uncategorized")
if not category_id:
# crete a new one
c = ExpenseCategoriesTable(self.user_id, u'Uncategorized')
db_session.add(c)
db_session.commit()
category_id = c.id
# find default account if not provided
if not account_id:
acc = Accounts(self.user_id)
account_id = acc.get_default_account()
if not account_id:
account_id = acc.add_default_account()
# add the actual expense
e = ExpensesTable(self.user_id, date, category_id, description, account_id, amount, pass_thru)
db_session.add(e)
db_session.commit()
# update the totals
self.totals.update_expense(amount, date)
return e.id
def add_user_work_experiences(user,
company_name,
position,
department,
entry_at,
is_resign=False,
dimission_at=None,
company_id=0):
"""
添加用户工作经历
"""
employer = UserEmployer()
employer.user_id = user.id
employer.nickname = user.nickname or user.email
employer.company_name = company_name
employer.company_id = company_id
employer.position = position
employer.department = department
employer.entry_at = entry_at
employer.is_resign = is_resign
if is_resign:
employer.dimission_at = dimission_at
else:
#解决sqlite不能插入默认字符串时间
employer.dimission_at = entry_at
db_session.add(employer)
db_session.commit()
return employer
def recruit_infantry_done(mesId, x, y, num): # 招募步兵完成事件
# time.sleep(timedelta)
mes = Message.query.filter(Message.messageId == mesId).first()
if mes is not None and mes.status != -1:
mes.status = 1
City.query.filter(City.posX == x and City.posY == y).first().infantry += num
db_session.commit()
def repo_rename():
if request.method == 'POST':
try:
old_reponame = request.form.keys()[0]
except IndexError:
old_reponame = ''
new_reponame = request.form.get(old_reponame, '')
old_name_file = BASE_DIR + '/conf/repos/' \
+ old_reponame + '.conf'
new_name_file = BASE_DIR + '/conf/repos/' \
+ new_reponame + '.conf'
if new_reponame.strip() != '' and new_reponame != old_reponame:
renamerepo = db_session.query(GitRepo).filter_by(
name=old_reponame).first()
renamerepo.name = new_reponame
db_session.commit()
db_session.close()
#~ repodict.pop(old_reponame)
new_lines = []
with open(old_name_file, 'rb') as f:
while True:
lines = f.readlines(8192)
if not lines:
break
for line in lines:
line = line.rstrip('\n')
line = re.sub('@' + old_reponame, '@' + new_reponame,
line)
new_lines.append(line)
with open(old_name_file, 'wb') as f:
f.truncate()
for _ in new_lines:
print >> f, _
os.rename(old_name_file, new_name_file)
return redirect(url_for('repo'))
def create_post():
user_id = session['user_id']
user = db_session.query(User).filter(User.user_id == user_id).first()
title = request.form['post_title']
content = request.form['post_content']
location_description = request.form['location_description']
longitude = request.form['longitude']
latitude = request.form['latitude']
style = request.form['post_style']
has_cipher = request.form['has_cipher']
cipher = request.form['post_cipher']
has_picture = request.form['has_picture']
new_post = Post(title=title,
content=content,
location_description=location_description,
longitude=longitude,
latitude=latitude,
style=style,
has_cipher=has_cipher,
has_picture=has_picture,
cipher=cipher,
create_time=datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
db_session.add(new_post)
user.posts.append(new_post)
db_session.commit()
if has_picture == '1':
post_picture = request.files['post_picture']
post_picture.save(sys.path[0] + "/post_picture/" +
str(new_post.post_id) + ".png")
app.logger.info("User %s created post successfully.", user_id)
return gen_json_success(None)
def create_script(challenge, type, payload):
"""
only gets called if is_working is 1
:param challenge:
:param type:
:param script:
:return:
"""
# get newest event
event = Event.query.order_by(Event.id.desc()).first()
s = Script()
s.name = type + ".py"
s.is_working = 1
s.challenge = challenge
s.type = type
s.event = event
db_session.add(s)
db_session.commit()
sp = ScriptPayload()
sp.script = s
sp.payload = payload.encode('utf8')
db_session.add(sp)
db_session.commit()
def user_similarity_db():
"""
:return: calculate all users similarity and insert this information in dabase
"""
deleted_rows = db_session.query(UserSimilarity).delete()
db_session.commit()
print("Deleted %i rows" % deleted_rows)
local_ = utils.pre_get_movies_by_user()
all_users = utils.get_all_users()
for i in all_users:
print("Calculating similarity of user %i" % i)
for j in all_users:
if i < j:
value = similarity_value(i, j, local_)
similarity_instance = UserSimilarity(i, j, value)
db_session.add(similarity_instance)
db_session.commit()
def hire_couriers(couriers: list):
ids = {"couriers": []}
for courier in couriers:
hours = courier["working_hours"]
regions = courier["regions"]
courier_id = courier["courier_id"]
courier_type = courier["courier_type"]
db_session.add(
Courier(
courier_id=courier["courier_id"],
courier_type=courier_type,
available_weight=WEIGHTS[courier_type]
)
)
for region_id in regions:
db_session.add(Region(courier_id=courier_id, region_id=region_id))
for hour in hours:
db_session.add(WorkingHour(courier_id=courier_id, working_hour=hour))
ids["couriers"].append({"id": courier_id})
db_session.commit()
return ids
def post(self):
"""A post request to this endpoint takes the base_image and
user_image submitted via json and checks the database to ensure
a match before issuing a token"""
current_user = get_jwt_identity()
if current_user is None:
response = jsonify({"msg": "unauthenticated"})
return (response.json), 401
if not request.is_json:
response = jsonify({"msg": "Missing JSON in request"})
return (response.json), 400
docker_image = request.json.get('image', None)
docker_tag = request.json.get('tag', None)
image_format = request.json.get('format', None)
if not (docker_image and docker_tag and image_format):
response = jsonify({"msg": "Missing parameter"})
return (response.json), 400
if not (image_format == 'qemu' or image_format == 'raw'):
response = jsonify(
{"msg":
"Only qemu and raw image formats are supported"}) # noqa
return (response.json), 400
query = User.query.filter_by(username=current_user).first()
user_id = query.uuid
status = 'building'
container_id = Container(user_id, docker_image, docker_tag, status,
image_format)
db.add(container_id)
db.commit()
tasks.build_image.apply_async(
args=[container_id.uuid, docker_image, docker_tag, image_format])
response = jsonify(status=status, id=container_id.uuid)
return (response.json), 200
def insert_task_to_db(openid, task, task_day, task_month, task_year, task_hour,
task_min):
import hashlib
hashstr = task + openid + task_day + task_month + task_year + task_hour + task_min
sha1obj = hashlib.sha1()
sha1obj.update(hashstr.encode('utf-8'))
task_ID = sha1obj.hexdigest()
t_id = Task.query.filter(Task.task_ID == task_ID).first()
if t_id is not None:
print(t_id + "已经在数据库!")
else:
t = Task(task_ID=task_ID,
task=task,
thour=task_hour,
tmin=task_min,
tyear=task_year,
tmonth=task_month,
tday=task_day)
try:
db_session.add(t)
db_session.commit()
return 1 # 成功返回 1
except Exception as e:
print('插入task到数据库错误: ' + str(e))
return -1 # 失败返回 -1
def customerEdit(customer_id):
# pdb.set_trace()
# this page will be for creating API Clients
try:
customer = db_session.query(User_Customer).filter_by(id=customer_id)
if customer.first():
if request.method == 'POST':
customer.update({
"name": request.form['customerName'], "phone": request.form['customerPhone'], "email": request.form['customerEmail'], 'status': request.form['customerStatus']})
db_session.commit()
flash('%s was sucessfully updated!' %
request.form['customerName'])
# return redirect(url_for('customerEdit', customer_id=customer.one().id))
return redirect(url_for('Customers', customers=db_session.query(User_Customer).filter_by(
user_id=current_user.id).all()))
else:
# pdb.set_trace()
return render_template('/customers/customerEdit.html', customer=customer.one())
else:
flash('Customer with Id %s not found!' % customer_id)
# return render_template('/customers/customers.html')
return redirect(url_for('Customers', customers=db_session.query(User_Customer).filter_by(
user_id=current_user.id).all()))
except:
db_session.rollback()
db_session.commit()
flash('Something went wrong, rolling back transactions!')
return redirect(url_for('Customers', customers=db_session.query(User_Customer).filter_by(
user_id=current_user.id).all()))
def validation_passwordreset(team_id, hash):
team = Team.query.filter_by(id=int(team_id)).first()
if not team:
flash("Team not found")
else:
if hash == team.password:
members = Member.query.filter_by(team=team)
users = [m.user for m in members]
pw = generate_password(length=9)
team.set_password(pw)
db_session.commit()
msg = Message(subject="Password Reset",
sender=config.MAIL_DEFAULT_SENDER,
reply_to=config.MAIL_REPLY_TO,
recipients=[u.email for u in users],
body="Password for your team was set to: {}".format(pw)
)
mail.send(msg)
flash('Email with new password was sent to all team members')
else:
flash("Incorrect Token")
return flask.redirect(flask.url_for('index'))
def unregister():
if current_user.is_authenticated:
flash("Please logout to use the unregister function.")
return redirect(url_for('index'))
form = UnregisterForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if not user:
flash("Email address not found")
return flask.redirect(flask.url_for('unregister'))
user.ensure_token()
db_session.commit()
msg = Message(subject="Unregister",
sender=config.MAIL_DEFAULT_SENDER,
reply_to=config.MAIL_REPLY_TO,
recipients=[user.email],
body="You requested your deletion from all CTF teams. To confirm use this URL"
" {}{}".format(
config.URL_BASE,
url_for("validation_unregister", token=user.token)),
)
mail.send(msg)
flash("Email was sent to your email address. Please follow the instructions in this email.")
return flask.render_template('unregister.html', form=form)
def level_up_barracks(name,x,y): #升级兵营
#city = City.query.filter(and_(City.posX==x , City.posY==y)).first()
city = City.query.filter((City.posX==x) & (City.posY==y)).first()
if city is None:
return 'Error: city not exist!'
if city.barracks >= city.minicipal:
return 'Fail: Minicipal Level Too Low.'
cost = (city.barracks*City.BasicPrice['barracks'][0],city.barracks*City.BasicPrice['barracks'][1],city.barracks*City.BasicPrice['barracks'][2],city.barracks*City.BasicPrice['barracks'][3])
if city.wood <= cost[0]:
return 'Fail: Wood Not Enough'
if city.stone <= cost[1]:
return 'Fail: Stone Not Enough'
if city.grass <= cost[2]:
return 'Fail: Grass Not Enough'
#if Message.query.filter(and_(Message.username == name, Message.event =='Level up' , Message.status==0)).first() is not None:
if Message.query.filter((Message.username == name) & (Message.event =='Level up') & (Message.status==0)).first() is not None:
return 'Fail: Another Construction Exist'
print 'OK'
city.wood-=cost[0]
city.stone-=cost[1]
city.grass-=cost[2]
mesId = len(Message.query.all())+1
db_session.add(Message(mesId,name,'system',cost[3],'Level up','Level up: Barracks'))
db_session.commit()
#level_up_barracks_done.delay(mesId,x,y,cost[3])
level_up_barracks_done.apply_async(args=[mesId,x,y], countdown=cost[3])
return 'Success!'
def attack(attackerPosX,attackerPosY,defenserPosX,defenserPosY,infantryNum,cavalryNum,archerNum):#进攻事件，接收参数：攻防双方坐标，士兵数目
#attacker = City.query.filter(and_(City.posX == attackerPosX, City.posY == attackerPosY)).first()
attacker = City.query.filter((City.posX == attackerPosX) & (City.posY == attackerPosY)).first()
#defenser = City.query.filter(and_(City.posX == defenserPosX, City.posY == defenserPosY)).first()
defenser = City.query.filter((City.posX == defenserPosX) & (City.posY == defenserPosY)).first()
if attacker is None or defenser is None:
return 'Error: city not exist!'
if attacker.infantry < infantryNum or attacker.cavalry < cavalryNum or attacker.archer<archerNum:
return 'Fail: Army not enough'
mesId1 = len(Message.query.all())+1
mesId2 = mesId1 + 1
#time_delta = timedelta(minutes = int(sqrt(attackerPosX*attackerPosX+attackerPosY*attackerPosY)*5))
countdown_ = int(sqrt(attackerPosX*attackerPosX+attackerPosY*attackerPosY)*300) #由距离算出到达秒数，用于延时调用
time_delta = timedelta(seconds = countdown_) #由秒数算出时间间隔，用于写入message
db_session.add(Message(mesId1,attacker.name,'system',time_delta,'Attack','Attack: from '+attacker.name+' to ' + defenser.name))
db_session.add(Message(mesId2,defenser.name,'system',time_delta,'Attack','Attack: from '+attacker.name+' to ' + defenser.name))
db_session.commit()
#attack_battle.delay(mesId1,mesId2,attackerPosX,attackerPosY,defenserPosX,defenserPosY,infantryNum,cavalryNum,archerNum,time_delta)
attack_battle.apply_async(args=[mesId1,mesId2,attackerPosX,attackerPosY,defenserPosX,defenserPosY,infantryNum,cavalryNum,archerNum], countdown=countdown_)
return 'Success!'
def set_state(team_id, service_id):
if request.args.get('secret') != API_SECRET:
abort(401)
event = Event.query.order_by(Event.id.desc()).first()
status = int(request.args.get('status'))
team_id = int(team_id)
service_id = int(service_id)
reason = request.args.get('reason')
if not status in [0, 1, 2]:
abort(400)
tss = TeamServiceState()
tss.attending_team = AttendingTeam.query.filter_by(id=team_id,
event=event).first()
tss.challenge = Challenge.query.filter_by(id=service_id,
type="ad",
event=event).first()
tss.state = status
if len(reason) > 248:
tss.reason = reason[:248] + "<cut>"
else:
tss.reason = reason
db_session.add(tss)
db_session.commit()
return jsonify({"result": "great success"})
def recruit_archer(name,x,y,num=1):#招募弓箭手
#city = City.query.filter(and_(City.posX==x , City.posY==y)).first()
city = City.query.filter((City.posX==x) & (City.posY==y)).first()
if city is None:
return 'Error: city not exist!'
if city.archer+city.cavalry+city.archer+num > city.barracks*10:
return 'Fail: Barracks Level Too Low.'
cost = (City.BasicPrice['archer'][0]*num,City.BasicPrice['archer'][1]*num,City.BasicPrice['archer'][2]*num,City.BasicPrice['archer'][3]*num)
if city.wood <= cost[0]:
return 'Fail: Wood Not Enough'
if city.stone <= cost[1]:
return 'Fail: Stone Not Enough'
if city.grass <= cost[2]:
return 'Fail: Grass Not Enough'
#if Message.query.filter(and_(Message.username == name, Message.event =='Recruit' , Message.status==0)).first() is not None:
if Message.query.filter((Message.username == name) & (Message.event =='Recruit') & (Message.status==0)).first() is not None:
return 'Fail: Another Recruit Exist'
print 'OK'
city.wood-=cost[0]
city.stone-=cost[1]
city.grass-=cost[2]
mesId = len(Message.query.all())+1
db_session.add(Message(mesId,name,'system',cost[3],'Recruit','Recruit: Archer'))
db_session.commit()
#recruit_archer_done.delay(mesId,x,y,num,cost[3])
recruit_archer_done.apply_async(args=[mesId,x,y,num], countdown=cost[3])
return 'Success!'
def transfer_cart(anony_id, userid):
orders = query_orders(anony_id)
for order in orders:
# 易主
order.userid = userid
print(order.userid, userid)
db_session.commit()
def apiClientEdit(api_client_id):
# pdb.set_trace()
# this page will be for creating API Clients
try:
client = db_session.query(User_Api_Client).filter_by(id=api_client_id)
if client.one():
if request.method == 'POST':
client.update({
"name": request.form['name'], "api_id": aes_encrypt(request.form['api_id']), "auth_id": aes_encrypt(request.form['auth_id'])})
db_session.commit()
flash('%s was sucessfully updated!' % request.form['name'])
return redirect(url_for('apiClientEdit', api_client_id=api_client_id))
else:
# pdb.set_trace()
apiClient = client.one()
id = apiClient.id
api_id = aes_decrypt(apiClient.api_id)
auth_id = aes_decrypt(apiClient.auth_id)
name = apiClient.name
return render_template('/apiClients/apiClientEdit.html', id=id, api_id=api_id, auth_id=auth_id, clientName=name)
else:
flash('API Client Id %s not found!' % api_client_id)
return render_template('/apiClients/apiClients.html')
except:
print('some error could not save transaction, rolling back')
db_session.rollback()
db_session.commit()
flash('API Client Id %s not found!' % api_client_id)
return render_template('/apiClients/apiClients.html')
def level_up_mill_done(mesId, x, y): # 升级伐木场完成事件
# time.sleep(timedelta)
mes = Message.query.filter(Message.messageId == mesId).first()
if mes is not None and mes.status != -1:
mes.status = 1
City.query.filter(City.posX == x and City.posY == y).first().mill += 1
db_session.commit()
def edit_expense(self,
date,
amount,
account_id,
expense_id,
description=None,
category_id=None,
pass_thru=False):
e = self.get_simple_expense(expense_id)
if e:
# update the totals
self.totals.update_expense(-float(e.amount), e.date)
# category and description not provided?
if not description: description = e.description
if not category_id: category_id = e.category
e.date, e.category, e.description, e.deduct_from, e.amount, e.pass_thru\
= date, category_id, description, account_id, amount, pass_thru
db_session.add(e)
db_session.commit()
# update the totals
self.totals.update_expense(amount, date)
return e # return so we see the updated values
def modify_loan_link(self, loan_id, percentage, original_amount):
le = ExpensesToLoansTable.query.filter(ExpensesToLoansTable.loan == loan_id)
if le:
for i in le:
i.percentage, i.original_amount = percentage, original_amount
db_session.add(i)
db_session.commit()
def registercheck():
if request.method == 'POST':
if request.form['username'] != "":
if request.form['password1'] != "":
if request.form['password1'] == request.form['password2']:
if (User.query.filter(User.username == request.
form['username']).first() == None):
NewUser = User(request.form['username'],
request.form['password1'])
new_posi = posi_ram()
NewCity = City(request.form['username'], new_posi[0],
new_posi[1])
db_session.add(NewUser)
db_session.add(NewCity)
db_session.commit()
return redirect(url_for('index'))
else:
error = 'the user already exists!'
else:
error = 'the password1 doesnot equal to password2!'
else:
error = 'the password has to be filled!'
else:
error = 'the username has to be filled!'
return render_template('register.html', error=error)
def dislikes():
if request.method == "PUT":
user_id = session['user_id']
post_id = request.form['post_id']
user = db_session.query(User).filter(User.user_id == user_id).first()
post = db_session.query(Post).filter(Post.post_id == post_id).first()
dislike_found = db_session.query(Dislike).filter(
Dislike.post_id == post_id and Dislike.user_id == user_id).first()
if dislike_found is None:
new_dislike = Dislike()
user.user_dislikes.append(new_dislike)
post.post_dislikes.append(new_dislike)
post.dislike_number += 1
db_session.add(new_dislike)
# remove old like
old_like = db_session.query(Like).filter(
Like.post_id == post_id and Like.user_id == user_id).first()
if old_like is not None:
db_session.delete(old_like)
post.like_number -= 1
db_session.commit()
data = {"dislike_post": True}
else:
dislike = db_session.query(Dislike).filter(
Dislike.post_id == post_id
and Dislike.user_id == user_id).first()
post.dislike_number -= 1
db_session.delete(dislike)
db_session.commit()
data = {"dislike_post": False}
return gen_json_success(data)
def modify_account_balance(self, account_id, amount):
a = AccountsTable.query.filter(AccountsTable.id == account_id).first()
if a:
a.balance += float(amount)
db_session.add(a)
db_session.commit()
def add_income(self, account_id, category_id, date, description, amount):
i = IncomeTable(self.user_id, date, category_id, description, account_id, amount)
db_session.add(i)
db_session.commit()
# update totals
self.totals.update_income(amount, date)
def add_expense(self,
date,
description,
amount,
category_id=None,
account_id=None,
pass_thru=False):
# add into uncategorized expenses if category not provided
if not category_id:
category_id = self.is_category(name="Uncategorized")
if not category_id:
# crete a new one
c = ExpenseCategoriesTable(self.user_id, u'Uncategorized')
db_session.add(c)
db_session.commit()
category_id = c.id
# find default account if not provided
if not account_id:
acc = Accounts(self.user_id)
account_id = acc.get_default_account()
if not account_id:
account_id = acc.add_default_account()
# add the actual expense
e = ExpensesTable(self.user_id, date, category_id, description,
account_id, amount, pass_thru)
db_session.add(e)
db_session.commit()
# update the totals
self.totals.update_expense(amount, date)
return e.id
def modify_account_balance(self, account_id, amount):
a = AccountsTable.query.filter(AccountsTable.id == account_id).first()
if a:
a.balance += float(amount)
db_session.add(a)
db_session.commit()
def apiDevicesScreenOn():
devices = db_session.query(Device).all()
for device in devices:
device.screen_enable = True
db_session.commit()
return jsonify("ok")
def apiDeviceAdd():
if request.headers['Content-Type'] == 'application/json':
device = Device(name=request.json['name'])
db_session.add(device)
db_session.commit()
else:
abort(400)
return jsonify(device.serialize())
def apiStreamAdd():
if request.headers['Content-Type'] == 'application/json':
stream = Stream(name=request.json['name'])
db_session.add(stream)
db_session.commit()
else:
abort(400)
return jsonify(stream.serialize())
def edit_account_transfer(self, date, deduct_from_account, credit_to_account, amount, transfer_id):
t = self.get_transfer(transfer_id)
if t:
t.date, t.from_account, t.to_account, t.amount = date, deduct_from_account, credit_to_account, amount
db_session.add(t)
db_session.commit()
return t # return so we see the updated values
def apiRoomAdd():
if request.headers['Content-Type'] == 'application/json':
room = Room(name=request.json['name'], )
db_session.add(room)
db_session.commit()
else:
abort(400)
return jsonify(room.serialize())
def add_income(self, account_id, category_id, date, description, amount):
i = IncomeTable(self.user_id, date, category_id, description,
account_id, amount)
db_session.add(i)
db_session.commit()
# update totals
self.totals.update_income(amount, date)
def delete_expense(self, expense_id):
e = self.get_expense(expense_id=expense_id)
# update the totals
self.totals.update_expense(-float(e[0].amount), e[0].date)
# delete
ExpensesTable.query.filter(ExpensesTable.id == expense_id).delete()
db_session.commit()
def delete_income(self, income_id):
i = self.get_income(income_id=income_id)
# update the totals
self.totals.update_income(-float(i.amount), i.date)
# delete
IncomeTable.query.filter(IncomeTable.id == income_id).delete()
db_session.commit()
def modify_loan_link(self, loan_id, percentage, original_amount):
le = ExpensesToLoansTable.query.filter(
ExpensesToLoansTable.loan == loan_id)
if le:
for i in le:
i.percentage, i.original_amount = percentage, original_amount
db_session.add(i)
db_session.commit()
def delete_expense(self, expense_id):
e = self.get_expense(expense_id=expense_id)
# update the totals
self.totals.update_expense(-float(e[0].amount), e[0].date)
# delete
ExpensesTable.query.filter(ExpensesTable.id == expense_id).delete()
db_session.commit()
def update():
for instance in City.query.all():
limit = (instance.storage) * 500
instance.grass = min((instance.grass + City.BasicProduction["grass"]), limit)
instance.wood = min((instance.wood + City.BasicProduction["wood"]), limit)
instance.stone = min((instance.stone + City.BasicProduction["stone"]), limit)
db_session.commit()
for instance in City.query.all():
print instance.username, instance.posX, instance.posY, instance.grass, instance.wood, instance.stone
def get_key(self):
k = UsersKeysTable.query\
.filter(UsersKeysTable.user == self.user_id)\
.filter(UsersKeysTable.expires > today_timestamp()).first()
# generate key
if not k:
k = UsersKeysTable(self.user_id)
db_session.add(k)
db_session.commit()
return k
def create_user(name):
'''A test module for creating users in the system'''
name = name.lower()
slug = slugify(name)
u = UsersTable(name.capitalize(), False, slug, slug)
db_session.add(u)
db_session.commit()
return make_response("User created", 200)
def add_user(email, password):
"""
添加用户
"""
user = User()
user.email = email
user.salt = random_str(6)
user.password = password_encrypt(password, user.salt)
db_session.add(user)
db_session.commit()
return user
def cancel_event(messageId): #取消事件，接收参数：消息Id
mes = Message.query.filter((Message.messageId == messageId) & (Message.status != 1)).first()
#if event != 'Attack' and event != 'Come Back':
#mes = Message.query.filter(and_(Message.messageId == messageId , Message.status != 1)).first()
#mes = Message.query.filter((Message.messageId == messageId) & (Message.status != 1)).first()
if mes is not None:
mes.status = -1
db_session.commit()
return 'Cancel Done'
else:
return 'Cancel Failed'
def modify_loan_balance(self, amount, with_user_id):
a = AccountsTable.query.filter(AccountsTable.user == self.user_id)\
.filter(AccountsTable.type == "loan")\
.filter(AccountsTable.name == with_user_id).first()
if not a:
a = AccountsTable(self.user_id, with_user_id, 'loan', float(amount)) # create new
else:
a.balance += float(amount) # update
db_session.add(a)
db_session.commit()
def edit_income(self, income_id, account_id, category_id, date, description, amount):
i = self.get_income(income_id)
if i:
# update totals
self.totals.update_income(-float(i.amount), i.date)
i.credit_to, i.category, i.date, i.description, i.amount = account_id, category_id, date, description, amount
db_session.add(i)
db_session.commit()
# update totals
self.totals.update_income(amount, date)
def create_user(data):
user = None
data = data.get('data')
if data:
user_id = data.get('id')
if user_id:
user = db_session.query(User).get(user_id)
else:
user = User(data.get('login'),data.get('name'),data.get('password'),data.get('email'))
db_session.add(user)
db_session.commit()
return jsonify({u'user': orm_to_dict(user) if user else None})
def init_project():
project = Project()
project.name = u'我的第一个项目'
db_session.add(project)
db_session.commit()
project_database = ProjectDatabase()
project_database.project_id = project.id
project_database.db_name = 'first.db'
project_database.db_type = DatabaseType.SQLITE
db_session.add(project_database)
db_session.commit()
def modify_user_balance(self, amount, account_id=None):
if not account_id:
a = AccountsTable.query.filter(AccountsTable.user == self.user_id).filter(AccountsTable.type != "loan")\
.order_by(asc(AccountsTable.id)).first()
else:
a = AccountsTable.query.filter(AccountsTable.user == self.user_id)\
.filter(AccountsTable.id == account_id).first()
if a:
a.balance += float(amount)
db_session.add(a)
db_session.commit()
def add_loan(self, other_user_id, date, description, amount, account_id=None):
# if an account id is not provided, get a 'default' account
if not account_id:
accounts = Accounts(self.user_id)
account_id = accounts.get_default_account()
# create a default account if no joy getting a default account
if not account_id:
account_id = accounts.add_default_account()
l = LoansTable(self.user_id, other_user_id, date, account_id, description, amount)
db_session.add(l)
db_session.commit()
return l.id
def dashboard():
'''Test budget dashboard'''
u = UsersTable(u"Admin", False, u"admin", u"admin")
db_session.add(u)
db_session.commit()
current_user_id = u.id
# get uncategorized expenses
exp = Expenses(current_user_id)
uncategorized_expenses = exp.get_entries(category_name="Uncategorized")
# get latest expenses
exp = Expenses(current_user_id)
latest_expenses = exp.get_entries(limit=5)
# get accounts
acc = Accounts(current_user_id)
accounts = acc.get_accounts_and_loans()
# split, get totals
assets, liabilities, loans, assets_total, liabilities_total = [], [], [], 0, 0
for a in accounts:
if a[0].type == 'asset':
assets.append(a)
assets_total += float(a[0].balance)
elif a[0].type == 'liability':
liabilities.append(a)
liabilities_total += float(a[0].balance)
elif a[0].type == 'loan':
# if we owe someone, it is our liability
if float(a[0].balance) < 0:
liabilities.append(a)
liabilities_total += float(a[0].balance)
else:
assets.append(a)
# get the monthly totals
t = Totals(current_user_id)
totals = t.get_totals()
return render_template('admin_dashboard.html', **locals())
#class SQLiteSequenceTable(Base):
# """SQLite sequence table"""
#
# __tablename__ = 'sqlite_master'
# rowid = Column(Integer, primary_key=True)
# name = Column(String(200))
# seq = Column(Integer)
def update_user(data):
user = None
data = data.get('data')
if data:
user_id = data.get('user_id')
if user_id:
user = db_session.query(User).get(user_id)
if user:
user.login = data.get('login')
user.name = data.get('name')
user.password = data.get('password')
user.email = data.get('email')
db_session.commit()
return jsonify({u'user': orm_to_dict(user) if user else None})
def attack_return(mesId, x, y, infantryNum, cavalryNum, archerNum, wood, stone, grass): # 战斗后攻击方返回事件，带回士兵和资源
# time.sleep(timedelta)
mes = Message.query.filter(Message.messageId == mesId).first()
mes.status = 1
city = City.query.filter(City.posX == x and City.posY == y).first()
city.infantry += infantryNum
city.cavalry += cavalryNum
city.archer += archerNum
city.wood += wood
city.stone += stone
city.grass += grass
db_session.commit()
def delete_loan(self, loan_id=None, slug=None):
if slug:
# find object id first
s = SlugsTable.query\
.filter(and_(SlugsTable.slug == slug, SlugsTable.type == 'loan', SlugsTable.user == self.user_id))\
.first()
loan_id = s.object_id
LoansTable.query.filter(and_(LoansTable.user == self.user_id, LoansTable.id == loan_id)).delete()
SlugsTable.query\
.filter(and_(SlugsTable.object_id == loan_id, SlugsTable.type == 'loan', SlugsTable.user == self.user_id))\
.delete()
db_session.commit()
def update_income(self, amount, date):
# generate a month/year string
m = MonthYear(date)
# get the corresponding entry
t = TotalsTable.query\
.filter(and_(TotalsTable.user == self.user, TotalsTable.month == str(m))).first()
if not t:
# brand spanking new
t = TotalsTable(self.user, str(m), 0, amount)
else:
# update the total
t.income += float(amount)
# save
db_session.add(t)
db_session.commit()
def edit_expense(self, date, amount, account_id, expense_id, description=None, category_id=None, pass_thru=False):
e = self.get_simple_expense(expense_id)
if e:
# update the totals
self.totals.update_expense(-float(e.amount), e.date)
# category and description not provided?
if not description: description = e.description
if not category_id: category_id = e.category
e.date, e.category, e.description, e.deduct_from, e.amount, e.pass_thru\
= date, category_id, description, account_id, amount, pass_thru
db_session.add(e)
db_session.commit()
# update the totals
self.totals.update_expense(amount, date)
return e # return so we see the updated values
def registercheck():
if request.method == 'POST':
if request.form['username'] != "" :
if request.form['password1'] != "":
if request.form['password1'] == request.form['password2']:
if (User.query.filter(User.username== request.form['username'] ).first() == None):
NewUser=User(request.form['username'],request.form['password1'])
new_posi=posi_ram();
NewCity=City(request.form['username'],new_posi[0],new_posi[1])
db_session.add(NewUser)
db_session.add(NewCity)
db_session.commit()
return redirect(url_for('index'))
else:
error = 'the user already exists!'
else :
error = 'the password1 doesnot equal to password2!'
else :
error = 'the password has to be filled!'
else :
error = 'the username has to be filled!'
return render_template('register.html', error=error)
