def EditItem(item_id):
if 'username' not in login_session:
return redirect(url_for('Login'))
item = session.query(Item).filter_by(id=item_id).one()
if item.user_id != userid_by_email(login_session['email']):
return "You are not the owner of this item."
if request.method == 'GET':
categories = session.query(Category).all()
item_to_edit = session.query(Item).filter_by(id=item_id).one()
return render_template('edititem.html',
categories=categories, item=item_to_edit)
if request.method == 'POST':
item_to_edit = session.query(Item).filter_by(id=item_id).one()
file = request.files['new-item-image']
filename = save_image(file)
add_photo_to_database(filename, item_to_edit)
submitted_category = request.form['category']
item_category = potential_new_category(submitted_category)
item_to_edit.name = request.form['new-item-name']
item_to_edit.description = request.form['new-item-description']
item_to_edit.category = item_category
session.add(item_to_edit)
session.commit()
flash('Item updated.')
return redirect(url_for('MyItems'))
def update(id):
try:
a = session.query(Employee).get(id)
if a != None:
firstname = request.json['firstname']
lastname = request.json['lastname']
# import pdb
# pdb.set_trace()
age = request.json['age']
skills = request.json['skills']
skill_obj = session.query(Skills).filter_by(emp_id=id).first()
if firstname.islower():
firstname = firstname.upper()
if lastname.islower():
lastname = lastname.upper()
a.firstname = firstname
a.lastname = lastname
a.age = age
skill_obj.tech = skills['tech']
session.commit()
updated_user = {
"firstname": firstname,
"lastname": lastname,
"age": age,
"skills": skills["tech"]
}
return updated_user
else:
return ("UserID incorrect")
except Exception as e:
return ("Cannot update entry")
def manager_test_pager(page):
start = (page - 1) * config.TEST_PAGER_SIZE
stop = start + config.TEST_PAGER_SIZE
test_pagers = db_session.query(TestPager)[start:stop]
total = len(test_pagers)
class_names = [class_.class_name for class_ in g.teacher_user.teacher_class]
classes = []
for class_name in class_names:
classs = db_session.query(Class).filter(Class.class_name==class_name).all()
classes.extend(classs)
for class_ in classes:
# 如果此班级的学生人数为0，则发布试卷可选班级则不显示此班级
if not class_.class_students:
classes.remove(class_)
classes = [class_.class_name for class_ in classes]
# 去掉重复的班级名
classes = list(set(classes))
content = {
'test_pagers': test_pagers,
'page': page,
'total': total,
'TEST_PAGER_SIZE': config.TEST_PAGER_SIZE,
'classes': classes
}
return render_template('front/front_manager_test_pager.html', **content)
def post_data(data):
check = session.query(User).filter_by(
public_display_name=data['public_display_name'])
if check == None:
raise Exception(
'This username is in use. Please, enter another username')
else:
public_display_name = data['public_display_name']
last_user = session.query(User).order_by(User.id.desc()).first()
session.add(
User(first_name=data["first_name"],
last_name=data['last_name'],
public_display_name=public_display_name,
about_me=data['about_me'],
profile_link=data['profile_link'],
email=data['email'],
password=data['password']))
session.commit()
last_user = session.query(User).order_by(User.id.desc()).first()
session.add(
PurchaseSettings(id=last_user.id,
credit_card='',
id_user=last_user.id,
id_plan=1))
session.commit()
def get(self, test_pager_id):
'''老师批阅以后，学生查看自己的试卷详情'''
stu = db_session.query(Student).filter(Student.student_id == g.student_user.student_id).first()
score = db_session.query(Score).filter(Score.socre_student == stu,
Score.score_test_pager_id == test_pager_id).first()
# 从数据库中抽取学生答题的结果集
choice_results = db_session.query(StudentChoiceResult).filter(
StudentChoiceResult.student_choice_result_student_id == g.student_user.student_id,
StudentChoiceResult.student_choice_result_test_pager_id == test_pager_id,
).all()
short_answer_results = db_session.query(StudentShortAnswerResult).filter(
StudentShortAnswerResult.student_short_answer_student_id == g.student_user.student_id,
StudentShortAnswerResult.student_short_answer_test_pager_id == test_pager_id,
).all()
program_results = db_session.query(StudentProgramResult).filter(
StudentProgramResult.student_program_student_id == g.student_user.student_id,
StudentProgramResult.student_program__test_pager_id == test_pager_id,
).all()
# 拿到学生对应题目的得分
content = {
'score': score,
'choice_results': choice_results,
'short_answer_results': short_answer_results,
'program_results': program_results,
}
return render_template('front/front_student_view_exam_pager.html', **content)
def get(self):
teacher_id = g.teacher_user.teacher_id
teacher = db_session.query(Teacher).filter(Teacher.teacher_id==teacher_id).first()
classes = teacher.teacher_class
classs = [] # 保存班级的名字
for class_ in classes:
clss = db_session.query(Class).filter(Class.class_name==class_.class_name).all()
classs.extend(clss)
# 老师可能管理多个班级，classs 是一个class对象列表
# 遍历列表找出所有classs班级中的学生，存储在列表students中
students = []
for class_ in classs:
stus = db_session.query(Student).filter(Student.student_class==class_).all()
students.extend(stus)
# 通过学生拿到学生的考卷
scores = []
for student in students:
scos = db_session.query(Score).filter(Score.socre_student==student, Score.score_state=='等待阅卷').all()
scores.extend(scos)
content = {
'scores': scores,
}
return render_template("front/front_teacher_exam_list.html", **content)
def agregar_producto(self, lista, userid):
total = 0
otro_producto = 's'
orden_canje_list = []
puntaje = session.query(User.puntaje).select_from(User).\
filter(User.user_id == userid).scalar()
print(f"Usted dispone de {puntaje} puntos\n")
while(otro_producto == 's'):
id_producto_seleccionado = int(input("\nIngrese numero de producto para canjear: "))
while(id_producto_seleccionado < 1 or id_producto_seleccionado > len(lista)):
id_producto_seleccionado = int(input("\nIngrese numero de producto valido: "))
producto = session.query(Producto).select_from(Producto).\
filter(Producto.id_producto==id_producto_seleccionado).scalar()
p_restantes = puntaje - total
if(total <= puntaje and producto.valor <= p_restantes):
total = total + producto.valor
print("Total de puntos a canjear hasta ahora: ", total)
prod_seleccionado = lista[id_producto_seleccionado - 1].get('descripcion')
print(prod_seleccionado)
orden_canje_list.append(producto)
else:
print("No le alcanzan los puntos. Seleccione otro producto.")
otro_producto = input("\nDesea canjear otro producto? s/n: ")
while(otro_producto!='s' and otro_producto!='n'):
otro_producto = input("Ingrese opcion correcta. Desea canjear otro producto? s/n: ")
print("----------------------------------------")
print("Termino de elegir, sus productos son:")
for productos in orden_canje_list:
print(productos.descripcion)
print("Por un total de: ", total)
print("----------------------------------------")
canjea = input("\nDesea confirmar su orden ahora o quiere editarla? c/e: ")
while(canjea != 'c' and canjea != 'e'):
canjea = input("Ingrese opcion correcta. Confirmar o editar? c/e: ")
if(canjea == 'c'):
orden_canje = Orden_canje()
orden_canje.user_id = userid
orden_canje.total = total
save(orden_canje)
sobra_puntos = puntaje - total
self.actualizar_puntos(sobra_puntos, userid)
self.generar_orden_producto(orden_canje_list)
elif(canjea == 'e'):
self.agregar_producto(self.productList,userid)
def update_user():
form = UpdateUserForm(request.form)
if form.validate():
uid = form.uid.data
name = form.name.data
email = form.email.data
phone = form.phone.data
is_super = form.is_super.data
user = db_session.query(Admin).filter(Admin.admin_uuid == uid).first()
required_phone = db_session.query(Admin).filter(
Admin.admin_phone == phone)[:]
required_email = db_session.query(Admin).filter(
Admin.admin_email == email)[:]
if len(required_phone) > 1: # 判断是否本人的手机号码
return '该手机号已被使用'
elif len(required_email) > 1:
return '该邮箱已被使用'
elif len(required_phone) == 1 and user.admin_phone != phone:
return '该手机号已被使用'
elif len(required_email) == 1 and user.admin_email != email:
return '该邮箱已被使用'
else:
user.admin_name = name
user.admin_email = email
user.admin_phone = phone
user.admin_is_super = is_super
db_session.commit()
return "success"
else:
errors = form.errors
error = errors.popitem()[1][0]
return error
def update_student():
form = UpdateStudentForm(request.form)
if form.validate():
id = form.id.data
name = form.name.data
email = form.email.data
phone = form.phone.data
class_ = form.class_.data
user = db_session.query(Student).filter(
Student.student_id == id).first()
required_phone = db_session.query(Student).filter(
Student.student_phone == phone)[:]
required_email = db_session.query(Student).filter(
Student.student_email == email)[:]
if len(required_phone) > 1: # 判断是否本人的手机号码
return '该手机号已被使用'
elif len(required_email) > 1:
return '该邮箱已被使用'
elif len(required_phone) == 1 and user.student_phone != phone:
return '该手机号已被使用'
elif len(required_email) == 1 and user.student_email != email:
return '该邮箱已被使用'
else:
user.student_name = name
user.student_email = email
user.student_phone = phone
user.student_class = Class(class_name=class_)
db_session.commit()
return "success"
else:
errors = form.errors
error = errors.popitem()[1][0]
return error
def remove_purchase_for_user_app(userid, appid):
try:
session.query(Purchase).filter(Purchase.user_id == userid).filter(Purchase.app_id == appid).delete()
session.commit()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to remove purchase")
def remove_purchase_for_user_app(userid, appid):
try:
session.query(Purchase).filter(Purchase.user_id == userid).filter(Purchase.app_id == appid).delete()
session.commit()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to remove purchase")
def opt_out_foreigners():
from constant import foreign_teams
f_team_query = session.query(Team.team_id).filter(
Team.team_name.in_(foreign_teams)).all()
f_team_ids = [t.team_id for t in f_team_query]
# リストでフィルターをかけているが、deleteの引数synchronize_sessionのデフォルト値'evaluate'ではこれをサポートしていない(らしい)からFalseを指定する
count = session.query(Record).filter(
Record.team_id.in_(f_team_ids)).delete(synchronize_session=False)
session.commit()
notify_line(f'{len(f_team_ids)}件の外国籍チームを検出。{count}件の記録を削除')
def put(self):
params = self.match_reqparse.parse_args()
print((params['previousIds']))
event_id = session.query(Event).filter_by(event_key = params['eventKey']).first().as_dict()['eventId']
if not event_id:
abort(400, 'event does not exist')
event_users = session.query(EmployerInfo).filter(EmployerInfo.event_id == event_id).all()
event_users = list(map(lambda user: user.as_dict(), event_users))
best_match = find_best_match(event_users, params['image'])
return best_match if best_match and best_match['userInfo']['userId'] not in params['previousIds'] else None
def add_records_wrapper(date_min, date_max):
target_meets = session.query(Meet.meet_id).filter(
Meet.start >= date_min,
Meet.start <= date_max).order_by(Meet.start).all()
target_meets_ids = [m.meet_id for m in target_meets]
if not_up_to_date := imperfect_meets(target_meets_ids):
count = session.query(Record).filter(
Record.meet_id.in_(not_up_to_date)).delete(
synchronize_session=False)
session.commit()
notify_line(f'大会ID:{not_up_to_date}、記録未納の可能性あり。{count}件の記録を削除')
def post(self, student_id, test_pager_id):
'''把分数表的学生得分改为学生的实际得分
再把学生对应的每道题的得分存入到对应的学生答案表中
'''
form = request.form
# 创建三个字典，键为题目的id号，值为该题得分
choice_score = {} # {"choice_id": 'score'}
short_answer_score = {} # {'short_answer_id':'score'}
program_score = {} # {'program_id':'score'}
for item in form:
# 判断表单项是选择题
if item[:6] == 'choice':
choice_score[item[6:]] = int(form[item])
elif item[:12] == 'short_answer':
short_answer_score[item[12:]] = int(form[item])
elif item[:7] == 'program':
program_score[item[7:]] = int(form[item])
score = db_session.query(Score).filter(
Score.score_student_id==student_id,
Score.score_test_pager_id==test_pager_id
).first()
# 合计学生的总分
score.score_student_socre = sum(map(sum, ([
[score for score in choice_score.values()],
[score for score in short_answer_score.values()],
[score for score in program_score.values()],
])))
score.score_state = '已经批阅'
# 保存学生答案表中学生具体每道题的得分
for choice_id in choice_score:
choice = db_session.query(StudentChoiceResult).filter(
StudentChoiceResult.student_choice_result_student_id == student_id,
StudentChoiceResult.student_choice_result_test_pager_id == test_pager_id,
StudentChoiceResult.student_choice_result_choice_id == choice_id
).first()
choice.student_choice_result_choice_score = choice_score[choice_id]
db_session.commit()
for short_answer_id in short_answer_score:
short_answer = db_session.query(StudentShortAnswerResult).filter(
StudentShortAnswerResult.student_short_answer_student_id == student_id,
StudentShortAnswerResult.student_short_answer_test_pager_id == test_pager_id,
StudentShortAnswerResult.student_short_answer_short_answer_id == short_answer_id,
).first()
short_answer.student_short_answer_score = short_answer_score[short_answer_id]
db_session.commit()
for program_id in program_score:
program = db_session.query(StudentProgramResult).filter(
StudentProgramResult.student_program_student_id == student_id,
StudentProgramResult.student_program__test_pager_id == test_pager_id,
StudentProgramResult.student_program_program_id == program_id,
).first()
program.student_program_score = program_score[program_id]
db_session.commit()
return redirect(url_for('front.teacher_exam_list', page=1))
def ViewCategory(category_name):
all_items = session.query(Item).all()
categories = session.query(Category).all()
items_in_category = []
for item in all_items:
if item.category.name.lower() == category_name.lower():
items_in_category.append(item)
return render_template('viewcategory.html',
category_name=category_name,
categories=categories,
items=items_in_category)
def post(self):
form = AddTestPagerForm(request.form)
if form.validate():
# 接收前台数据
choiceSize = int(request.form["choiceSize"])
choiceScore = int(request.form["choiceScore"])
shortAnswerSize = int(request.form["shortAnswerSize"])
shortAnswerScore = int(request.form["shortAnswerScore"])
programSize = int(request.form["programSize"])
programScore = int(request.form["programScore"])
type = request.form["type"]
name = request.form['name'].strip()
# 试卷的总分等于 =
# 选择器的个数*单个选择题的分值 + 简答题的个数*单个简答题的分值 + 程序设计题的个数*单个程序设计提的分值
totalscore = (choiceSize*choiceScore) + (shortAnswerSize*shortAnswerScore) + (programSize*programScore)
count_choice = db_session.query(Choice).filter(Choice.choice_type==type).count()
count_short_answer = db_session.query(ShortAnswer).filter(ShortAnswer.short_answer_type==type).count()
count_program = db_session.query(Program).filter(Program.program_type==type).count()
# 如果数据库选择题的个数小于需要生成的个数
if count_choice < choiceSize:
# 把所有的题全部抽出来
choices = db_session.query(Choice).all()
message1 = '题库中选择题不够%s个, 现已全部引用' % choiceSize
# 如果需要生成的选择题的个数小于数据库中存储的数量
else:
choices = db_session.query(Choice).order_by(func.rand(Choice.choice_id))[0:choiceSize]
if count_short_answer < shortAnswerSize:
short_answers = db_session.query(ShortAnswer).all()
message2 = '题库中简答题不够%s个, 现已全部引用' % shortAnswerSize
else:
short_answers = db_session.query(ShortAnswer).order_by(func.rand(ShortAnswer.short_answer_id))[0:shortAnswerSize]
if count_program < programSize:
programs = db_session.query(Program).all()
message3 = '题库中简答题不够%s个, 现已全部引用' % programSize
else:
programs = db_session.query(Program).order_by(func.rand(Program.program_id))[0:programSize]
# 创建试卷对象
test_pager = TestPager(test_pager_name=name, test_pager_type=type, test_pager_choice_score=choiceScore,
test_pager_short_answer_score=shortAnswerScore, test_pager_program_score=programScore,
test_pager_choice_num=choiceSize, test_pager_short_answer_num=shortAnswerSize,
test_pager_program_num=programSize, test_pager_total_score=totalscore)
# 选择题，简答题，程序设计题绑定到试卷中
test_pager.test_pager_choices.extend(choices)
test_pager.test_pager_short_answers.extend(short_answers)
test_pager.test_pager_programs.extend(programs)
db_session.add(test_pager)
db_session.commit()
content = {
# 'message1': message1,
# 'message2': message2,
# 'message3': message3,
'totalScore': totalscore
}
return render_template('front/front_add_test_page.html', **content)
else:
message = form.errors.popitem()[1][0]
return render_template('front/front_add_test_page.html', message=message)
def initialize_stats_table():
session.query(Stats).delete()
session.commit()
for pool in [0, 1]:
for sex in [1, 2]:
for style_and_distance in [
11, 12, 13, 14, 15, 16, 17, 21, 22, 23, 24, 31, 32, 33, 34,
41, 42, 43, 44, 53, 54, 55, 63, 64, 65, 66, 73, 74, 75
]:
for grade in range(20):
event = sex * 100 + style_and_distance
session.add(Stats(pool=pool, event=event, grade=grade))
session.commit()
def delete_user(id):
try:
user = session.query(Employee).get(id)
user2 = session.query(Skills).filter_by(emp_id=id).first()
#if user user2 !=None:
session.delete(user)
session.delete(user2)
session.commit()
final = {"firstname": user.firstname, "lastname": user.lastname}
return final
except Exception as e:
return e
session.rollback()
def bind_user():
'''在进入前端首页之前绑定用户'''
if config.STUDENT_EMAIL in session:
email = session[config.STUDENT_EMAIL]
student_user = db_session.query(Student).filter(
Student.student_email == email).first()
if student_user:
g.student_user = student_user
if config.TEACHER_EMAIL in session:
email = session[config.TEACHER_EMAIL]
teacher_user = db_session.query(Teacher).filter(
Teacher.teacher_email == email).first()
if teacher_user:
g.teacher_user = teacher_user
def application(id):
try:
return session.query(Application).filter(Application.id == int(id)).one()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select application")
def make_user(login_session):
new_user = User(name=login_session['username'],
email=login_session['email'])
session.add(new_user)
session.commit()
user = session.query(User).filter_by(email=login_session['email']).one()
return user.id
def purchase(id):
try:
return session.query(Purchase).filter(Purchase.id == id).one()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select purchase")
def add_user():
try:
#user1 = session.query(Employee).all()
#user2 = session.query(Skills).all()
firstname = request.json["firstname"]
lastname = request.json["lastname"]
age = request.json["age"]
skill = request.json["skills"]
if firstname.islower():
upper_firstname = firstname.upper()
if firstname.islower():
upper_lastname = lastname.upper()
user_details = Employee(firstname=upper_firstname,
lastname=upper_lastname,
age=age)
user_details.commit_user_details()
#session.flush()
user_id = session.query(Employee).filter_by(
firstname=upper_firstname).first()
for tech in skill:
user_skill = Skills(emp_id=user_id.id, tech=skill[tech])
user_skill.commit_skill()
z = {
"firstname": upper_firstname,
"lastname": upper_lastname,
"age": age,
"skills": skill["tech"]
}
return z
except Exception as e:
return ("invalid entry")
def purchase_for_user_app(userid, appid):
try:
return session.query(Purchase).filter(Purchase.user_id == userid).filter(Purchase.app_id == appid).first()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select purchases for user")
def applications():
try:
return session.query(Application).all()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select applications")
def application(id):
try:
return session.query(Application).filter(Application.id == int(id)).one()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select application")
def user(id):
try:
return session.query(User).filter(User.id == id).first()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select user")
def identity_by_identifier(identifier):
try:
return session.query(Identity).filter(Identity.identifier == identifier).first()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select identity for identifier")
def getLast(Gi_query):
# Deserialize Gi object from DB
gi_obj = session.query(Gi).filter_by(gi=Gi_query).first()
if gi_obj is None:
return {'Gi': Gi_query, 'cQueue': gList()}
else:
return gi_obj
def todo(self):
# met les devoirs dans ToDo
self.connectTodo()
# charge le fichier avec les devoirs deja ajouté
lineDev = session.query(Config).one()
if lineDev.devoirs != None:
devoirs = json.loads(lineDev.devoirs)
else:
devoirs = []
if self.client.logged_in and self.todo_client and self.listeToDo:
# récupère la liste todo dans laquelle il faut mettre les devoirs
lists = self.todo_client.get_lists()
task_list = None
for list in lists:
if list.displayName == self.listeToDo:
task_list = list
break
if task_list == None:
self.todo_client.create_list(name=self.listeToDo)
# récupére tous les devoirs pour les 30 prochains jours
homeworks = self.client.homework(date.today(),
date.today() + timedelta(days=30))
for homework in homeworks:
# création de l'id
id = homework.description[0:10] + \
homework.date.strftime("%Y-%m-%dT%H:%M:%S")
# si le devoir n'est pas fini est qu'il n'est pas encore dans todo on l'ajoute
if homework.done == False and id not in devoirs:
self.todo_client.create_task(
title=
f'{homework.subject.name[0:5]} {homework.description[0:100]}',
list_id=task_list.list_id,
due_date=homework.date,
body_text=
f'{homework.subject.name} : {homework.description}')
devoirs.append(id)
# Si il est fait on le coche sur todo
else:
tasks = self.todo_client.get_tasks(
list_id=task_list.list_id, status='notCompleted')
for task in tasks:
if task.dueDateTime == homework.date and task.body == homework.description:
self.todo_client.complete_task(
task_id=task.task_id,
list_id=task_list.list_id)
break
# récupére tous les devoirs fait
tasks = self.todo_client.get_tasks(list_id=task_list.list_id,
status='completed')
# on coche le devoirs sur pronote
for task in tasks:
homeworks = self.client.homework(
date.today(),
date.today() + timedelta(days=30))
for homework in homeworks:
if task.dueDateTime == homework.date and task.body == homework.description:
homework.set_done(status=True)
self.line.devoirs = json.dumps(devoirs)
session.commit()
def user(id):
try:
return session.query(User).filter(User.id == id).first()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select user")
def purchase_for_user_app(userid, appid):
try:
return session.query(Purchase).filter(Purchase.user_id == userid).filter(Purchase.app_id == appid).first()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select purchases for user")
def identity_by_identifier(identifier):
try:
return session.query(Identity).filter(Identity.identifier == identifier).first()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select identity for identifier")
def purchase(id):
try:
return session.query(Purchase).filter(Purchase.id == id).one()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select purchase")
def applications():
try:
return session.query(Application).all()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select applications")
def post(self):
params = self.post_reqparse.parse_args()
linkedin_info = params['linkedinInfo']
event_key = params['eventKey']
# find matching event (validating QR code)
event_id = None
matched_event = session.query(Event).filter_by(event_key = event_key).first()
if matched_event:
event_id = matched_event.as_dict()['eventId']
else:
abort(400, 'No event matched this key!')
# add a user and their photo if they don't already exist
matching_user = session.query(Entity).filter_by(name = linkedin_info['formattedName']).first()
user_id = None
if matching_user is None:
if (linkedin_info['pictureUrls'] and len(linkedin_info['pictureUrls']['values']) > 0):
new_user = Entity(str(linkedin_info['formattedName']), str(linkedin_info['pictureUrls']['values'][0]))
session.add(new_user)
session.commit()
user_id = new_user.as_dict()['userId']
else:
abort(400, 'No profile pictures for the authenticated user')
else:
user_id = matching_user.as_dict()['userId']
# add that user's linkedin info for a specific event, if it doesn't already exist
if session.query(EmployerInfo).filter_by(user_id = user_id, event_id = event_id).first() is None:
summary = linkedin_info['summary'] if 'summary' in linkedin_info.keys() else 'Nothing to see here...'
headline = linkedin_info['headline'] if 'headline' in linkedin_info.keys() else 'Talk to me to find out more!'
email = linkedin_info['emailAddress'] if 'emailAddress' in linkedin_info.keys() else 'No email found.'
user_info = EmployerInfo(user_id, event_id, summary, headline, linkedin_info['publicProfileUrl'], email)
session.add(user_info)
session.commit()
# add positions
if 'values' in linkedin_info['positions'].keys():
for position in linkedin_info['positions']['values']:
date_start = str(position['startDate']['month']) + "/" + str(position['startDate']['year'])
date_end = str(position['endDate']['month']) + "/" + str(position['endDate']['year']) if 'endDate' in position.keys() else None
position_to_add = EmployerJob(user_info.as_dict()['employerInfoId'], position['location']['name'], position['title'], position['company']['name'], date_start, date_end, position['isCurrent'])
session.add(position_to_add)
session.commit()
return "Success!"
def categories(parent=None):
try:
q = session.query(Category)
if parent:
q = q.filter(Category.parent_id == parent)
return q.all()
except Exception, e:
logging.exception(e)
session.rollback()
raise ValueError("Unable to select categories")
def save_sms(self, type, name, number, content, create_at):
sms = session.query(Sms).filter_by(number=number,
create_at=create_at).first()
if not sms is None: # 重复的短信
raise DuplicateError
sms = Sms()
sms.create_at = create_at
sms.number = number
sms.type = type
sms.content = content
if not name is None:
name = name.replace(' ', '')
name = name.replace('!', '')
name = name.replace(u'！', '')
if not name is None: # 保存联系人
contact_phone_items = session.query(Contact, Phone). \
filter(Contact.id == Phone.contact_id). \
filter(Phone.number == number).all()
if len(contact_phone_items) > 0: # 已有联系人
contact, phone = contact_phone_items[0]
else: # 新建联系人
contact = session.query(Contact).filter_by(name=name).first()
if contact is None:
contact = Contact(name=name)
session.add(contact)
phone = Phone(number)
phone.contact = contact
contact.adjust_name()
session.commit()
sms.contact = contact
sms.phone = phone
self.smses.append(sms)
def update_sms():
"""更新短信联系人为空的短信"""
number_rows = session.execute("""
select distinct number, phone_id, contact_id
from sms
where contact_id is null;""")
for row in number_rows.fetchall():
number = row['number']
sms = session.query(Sms).filter(
and_(Sms.number.like('%' + number), Sms.contact_id != None)
).first()
if sms is not None:
session.execute(
"""
update sms
set contact_id = :contact_id, phone_id = :phone_id
where number =:number;""",
{'contact_id': sms.contact_id,
'phone_id': sms.phone_id,
'number': sms.number}
)
session.commit()
def find_by(cls, **filter): return session.query(cls).filter_by(**filter).first()
def all(cls): return session.query(cls).all()
