def dao_get_sprints_between_daterange(_project_id, started_on, end_started_on):
return db.Session().query(TeamMetric).filter(
and_(
TeamMetric.project_id == _project_id,
TeamMetric.started_on >= started_on,
TeamMetric.started_on <= end_started_on,
)).order_by(TeamMetric.started_on).all()
def sign_up():
username = request.values.get('userName')
pwd = request.values.get('pwd')
nickname = request.values.get('nickname')
sex = request.values.get('sex')
mobile = request.values.get('mobile')
birthday = request.values.get('birthday')
portrait = request.values.get('portrait')
with db.Session() as session:
rs = session.query(Member.username).filter(
db.and_(Member.username == username)).all()
if len(rs) != 0:
return jsonify(dict(statusCode="401"))
else:
session.add(
Member(
username=username,
password=pwd,
nickname=nickname,
sex=Member.SEX_FEMALE if sex == "F" else Member.SEX_MALE,
mobile=mobile,
birthday=datetime.datetime.strptime(birthday, "%Y-%m--%d"),
portrait=portrait, # 应当是一个图片
created_dt=datetime.datetime.now(),
valid=Member.VALID_VALID))
session.add(
MemberLog(username=username, action=MemberLog.ACTION_INSERT))
return jsonify(dict(statusCode="200", sessionKey=""))
def get_userinfo():
sessionKey = request.values.get("sessionKey")
username = sessionKey2Username.get(sessionKey)
with db.Session() as session:
members = session.query(Member).filter(
db.and_(Member.username == username)).all()
# todo 定义新的两个model
histories = session.query(MemberUseLog).filter(
db.and_(MemberUserLog.username == username)).all()
favorites = session.query(MemberStar).filter(
db.and_(MemberStar.username == username)).all()
if len(members) == 0:
return jsonify(dict(statusCode="400"))
else:
member = members[0]
return jsonify(
dict(statusCode="200",
nickName=member.nickname,
portrait=member.portrait,
sex=member.sex,
history='\t'.join(
list(map(lambda history: history.fil_id, histories))),
favority='\t'.join(
list(map(lambda favorite: favorite.fil_id,
favorites)))))
def test_db():
db.init_db(os.environ.get('DATABASE_URL_TEST'))
db.create_all()
session = db.Session()
yield session
session.close()
db.drop_all()
def dao_get_git_metrics_between_daterange(team_id, start_date, end_date):
return db.Session().query(GitMetric).filter(
and_(
GitMetric.team_id == team_id,
GitMetric.end_date >= start_date,
GitMetric.end_date <= end_date,
)).order_by(GitMetric.end_date).all()
def post(self):
"""
Register a new user account
:return: HTTP 200: Successfully created a new user account: Account object
https://docs.todo.chuvash.pw/#/account/post_account_
"""
req = flask.request
data = req.get_json(silent=True)
if data is None:
return {'error': 'Only JSON data is supported'}, 400
if not ('username' in data and 'email' in data):
return {'error': 'username and email are required'}, 400
# TODO additional checks of course
s = db.Session()
try:
new_user = User(username=data['username'], email=data['email'])
s.add(new_user)
s.commit()
except IntegrityError:
return {'error': "User with this email already exists"}, 409
return new_user.get_api_repr(include_email=True)
def dao_add_sprint(metric):
metric_exists = db.Session().query(TeamMetric).filter_by(
project_id=metric.project_id, sprint_id=str(metric.sprint_id)).first()
if metric_exists:
return
db.save(TeamMetric(**metric.__dict__))
class GoodBoyPointForm(FlaskForm):
dbSession = db.Session()
users = dbSession.getUsers()
email = SelectField("User", choices=users, validators=[DataRequired()])
points = DecimalField("Points Awarded", validators=[DataRequired()])
description = StringField("Description", validators=[DataRequired()])
submit = SubmitField("Submit Request")
def get(self, user_id):
if user_id is None:
return {'error': 'user_id is required'}, 400
s = db.Session()
try:
user = s.query(User).filter_by(id=user_id).one()
except NoResultFound:
return {'error': 'User not found'}, 404
return user.get_api_repr(include_email=False)
def dao_upsert_sprint(metric):
db_metric = db.Session().query(TeamMetric).filter_by(
project_id=metric.project_id, sprint_id=str(metric.sprint_id)).first()
if db_metric:
db.update(TeamMetric,
filters={
'project_id': metric.project_id,
'sprint_id': metric.sprint_id
},
**metric.__dict__)
else:
db.save(TeamMetric(**metric.__dict__))
def modify_user():
username = request.values.get('userName')
pwd = request.values.get('pwd')
nickname = request.values.get('nickname')
sex = request.values.get('sex')
mobile = request.values.get('mobile')
birthday = request.values.get('birthday')
portrait = request.values.get('portrait')
with db.Session() as session:
rs = session.query(Member).filter(
db.and_(Member.username == username)).all()
if len(rs) == 0:
return jsonify(dict(statusCode="401"))
else:
member = rs[0]
session.add(
MemberLog(
username=username,
action=MemberLog.ACTION_UPDATE,
his_nickname=member.nickname,
his_sex=member.sex,
his_password=member.password,
his_mobile=member.mobile,
his_email=member.email,
his_birthday=member.birthday,
his_portrait=member.portrait,
created_dt=datetime.datetime.now(),
))
member.update({
'username':
username,
'password':
pwd,
'nickname':
nickname,
'sex':
Member.SEX_FEMALE if sex == "F" else Member.SEX_MALE,
'mobile':
mobile,
'birthday':
datetime.datetime.strptime(birthday, "%Y-%m--%d"),
'portrait':
portrait, # 应当是一个图片
})
return jsonify(dict(statusCode="200", sessionKey=""))
def __init__(self):
self.dbSession = db.Session()
self.responseForms = responseForms.Session()
self.penalties = {
"Food Not Put Away": .5, # 1/2
"Intense Dirty Dishes": .35, # 1/3
"Mild Dirty Dishes": .20, # 1/5
"Intense Dirty Food Warmers": .25, # 1/2
"Mild Dirty Food Warmers": .17, # 1/6
"Intense Serving Table Not Wiped": .25, # 1/4
"Mild Serving Table Not Wiped": .20, # 1/5
"Utensils Not Ran": 0.20, # 1/5
"Cutting Boards Not Cleaned": 0.10 # 1/10
}
def get(self):
"""
Get current user's account
:return: HTTP 200: User account info
https://docs.todo.chuvash.pw/#/account/get_account_
"""
s = db.Session()
try:
account = s.query(User).filter_by(id=g.auth['user_id']).one()
except NoResultFound:
return {'error': 'Account not found'}, 404
return account.get_api_repr(include_email=True)
def dao_upsert_git_metric(metric):
db_metric = db.Session().query(GitMetric).filter_by(
team_id=metric["team_id"],
name=metric["name"],
pr_number=metric["pr_number"]).first()
if db_metric:
db.update(GitMetric,
filters={
'team_id': metric["team_id"],
'name': metric["name"],
'pr_number': metric["pr_number"]
},
**metric)
else:
db.save(GitMetric(**metric))
def tdtrade():
dbSession = db.Session()
mode = request.args.get('mode')
token = request.args.get('token')
uid = request.args.get('uid')
mealDateId = request.args.get('mealDateId')
tradeUid = request.args.get('tradeUid')
if dbSession.voidSwapKey(token):
if mode == "trade":
tradeDateId = request.args.get('trade')
dbSession.swapAssignment(uid, tradeUid, mealDateId)
dbSession.swapAssignment(tradeUid, uid, tradeDateId)
if mode == "purchase":
dbSession.swapAssignment(uid, tradeUid, mealDateId)
dbSession.close()
return redirect(url_for('.tdinfo'))
def sign_in():
"""一个返回JSON数据接口的设计示例"""
username = request.values.get('userName')
pwd = request.values.get('pwd')
with db.Session() as session:
pwds = session.query(Member.password).filter(
db.and_(
Member.username == username,
Member.valid == 1,
)).all()
if len(pwds) == 0 or pwds[0] != pwd:
return jsonify(dict(statusCode="401"))
else:
return jsonify(dict(statusCode="200", sessionKey=""))
def db_session():
"""Sets up the DB engine using the local postgres instance
Hijacks the transaction decorator to control the transaction as
part of the test
"""
session = db.Session()
@contextmanager
def _dummy_transaction():
yield session
with mock.patch('app.db.transaction', _dummy_transaction):
try:
yield session
finally:
session.rollback()
session.close()
def delete(self):
"""
Completely delete current users account with all of the lists associated with it.
:return: HTTP 200: The account was successfully deleted
https://docs.todo.chuvash.pw/#/account/delete_account_
"""
s = db.Session()
try:
account_to_delete = s.query(User).filter_by(
id=g.auth['user_id']).one()
s.delete(account_to_delete)
s.commit()
except NoResultFound:
return {'error': "Account was already deleted"}, 404
return 'ok', 200
def process_request(self, req, resp):
req.context['session'] = db.Session()
def TakedownTradeMessage(uid, dateId, traders):
debug = 1
url = ['104.194.115.143', 'localhost'][debug]
dbSession = db.Session()
curMeal = dbSession.getCurMealDateId()
token = dbSession.getSwapKey()
uname = dbSession.getPname(uid)
tid = dbSession.getTid(dateId)
date = parse(dbSession.getIsoDate(dateId))
meal = ["Lunch", "Dinner"][tid % 2]
weekday = ["Monday", "Tuesday", "Wednesday", "Thursday",
"Friday"][date.weekday()]
subject = f"Trade Requested - {weekday} {meal} for {uname}"
_meal = meal
for trader in traders:
traderName = dbSession.getPname(trader)
traderMeals = dbSession.getUserAssignments(trader)
tradeLinks = "<ul>"
for meal in traderMeals:
if meal[0] < curMeal:
continue
tradeMealTid = dbSession.getTid(meal[0])
tradeMealDateTime = dbSession.getIsoDate(meal[0])
purchaseUrl = ""
mealtime = ["Lunch", "Dinner"][tradeMealTid % 2]
day = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"][int(
(tradeMealTid - tradeMealTid % 2) / 2)]
if tradeMealTid in dbSession.getUserAvailibility(uid):
payload = {
"mode": "trade",
"uid": uid,
"mealDateId": dateId,
"tradeDateId": meal[0],
"tradeUid": trader,
"token": token
}
r = requests.Request('GET',
'http://104.194.115.143:5000/tdtrade',
params=payload).prepare()
tradeLinks += f"<li><strong>{day} {mealtime}, {tradeMealDateTime[:10]}:</strong> {r.url}"
tradeLinks += "</ul>"
payload = {
"mode": "purchase",
"uid": uid,
"mealDateId": dateId,
"tradeUid": trader,
"token": token
}
r = requests.Request('GET',
'http://104.194.115.143:5000/tdtrade',
params=payload).prepare()
purchaseUrl = r.url
mealDateTime = dbSession.getIsoDate(dateId)
message = f"""
<h3>{traderName},<h3>
<p>{uname} is looking to trade their {weekday} {_meal} takedown, on {mealDateTime[:10]}.</p>
<br>
<p>Please click a link below to trade for that takedown.</p>"""
message += "<h5>Tradeable Takedowns:</h5>"
message += tradeLinks
message += "<h5>Alternatively, you can take the takedown and recieve a credit.<h5>"
message += f"{purchaseUrl}"
message += "<p><br>With a cold, mechanical heart,<br><i>The Takedowns Automation Project</i></p>"
rEmail = dbSession.getEmail(trader)
SendMessage(rEmail, subject, message, message)
def tdinfo():
dbSession = db.Session()
userLoginForm = UserLoginForm()
takedownTradeForm = TakedownTradeForm()
stats = dbSession.getTDStats()
def tdPage(userEmail):
if userEmail is None:
user = [None]
else:
uid = dbSession.getUid(userEmail)
pname = dbSession.getPname(uid)
tdScore = dbSession.getTakedownScore(uid)
penaltyScore = dbSession.getPenaltyBalance(uid)
userPenalties = dbSession.getPenalties(uid)
userAssignments = dbSession.getUserAssignments(uid)
assignments = []
if userAssignments:
for dateId in userAssignments:
tid = dbSession.getTid(dateId[0])
date = dbSession.getIsoDate(dateId[0])
meal = ["Lunch", "Dinner"][tid % 2]
day = [
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"
][int((tid - tid % 2) / 2)]
assignments.append([day + " " + meal, date, dateId[0]])
user = [pname, tdScore, penaltyScore, userPenalties, assignments]
resp = make_response(
render_template("tdinfo.html",
user=user,
userLoginForm=userLoginForm,
takedownTradeForm=takedownTradeForm,
stats=stats))
if userEmail:
resp.set_cookie("userEmail", userEmail)
dbSession.close()
return resp
if userLoginForm.submit.data and userLoginForm.validate_on_submit():
userEmail = userLoginForm.email.data
dbSession.close()
return tdPage(userEmail)
if takedownTradeForm.submitData.data and takedownTradeForm.validate_on_submit(
):
userEmail = takedownTradeForm.email.data
uid = dbSession.getUid(userEmail)
dateId = takedownTradeForm.dateId.data
tid = dbSession.getTid(dateId)
traders = dbSession.getAvailibility(tid)
mail.TakedownTradeMessage(uid, dateId, traders)
dbSession.close()
return tdPage(userEmail)
try:
userEmail = request.cookies.get("userEmail")
# dbSession.close()
return tdPage(userEmail)
except Exception:
# dbSession.close()
return tdPage(None)
class UserLoginForm(FlaskForm):
dbSession = db.Session()
users = dbSession.getUsers()
email = SelectField("User", choices=users, validators=[DataRequired()])
submit = SubmitField("See User Info")
def dao_get_sprints():
return db.Session().query(TeamMetric).all()
class TakedownTradeForm(FlaskForm):
dbSession = db.Session()
users = dbSession.getUsers()
email = SelectField("User", choices=users, validators=[DataRequired()])
dateId = IntegerField("Meal ID", validators=[DataRequired()])
submitData = SubmitField("Submit Trade Request")
def dao_get_git_metrics():
return db.Session().query(GitMetric).all()
