def postTask(request=None, task_id=None, **kw):
uid = auth.current_user(request)
data = request.json
if uid is not None:
note = data['note']
followers = data['followers']
new_task = convertNewTask(data, uid)
db.session.add(new_task)
db.session.flush()
for follower in followers:
follower_task = FollowerTask(user_id=follower['id'],
task_id=new_task.id,
created_at=new_task.start_time,
note=note)
db.session.add(follower_task)
db.session.commit()
return json(request.json, status=201)
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
def getManyGroup(request=None, search_params=None, **kwargs):
uid = auth.current_user(request)
if uid is not None:
if 'filters' in search_params and bool(search_params["filters"]):
filters = search_params["filters"]
if "$and" in filters:
search_params["filters"]['$and'].append(
{"user_id": {
"$eq": uid
}})
else:
search_params["filters"] = {}
search_params["filters"]['$and'] = [{
"user_id": {
"$eq": uid
}
}, filters]
else:
search_params["filters"] = {'$and': [{"user_id": {"$eq": uid}}]}
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
def current_user(request):
uid = auth.current_user(request)
if uid is not None:
user = couchdb.db.get_query_result(
{'doc_type': 'user', '_id': uid}, raw_result=True)
return user
return None
async def addMembers(request=None, group_id=None):
uid = auth.current_user(request)
if uid is not None:
data = request.json
phone = data.get("phone")
group_id = data.get("group_id")
user_id = db.session.query(User.id).filter(
User.phone == phone, User.is_active == True).first()
if user_id is not None:
id_role_member = db.session.query(
Role.id).filter(Role.role_name == "member").first()
check_is_member = db.session.query(GroupsUsers.id).filter(
GroupsUsers.user_id == user_id,
GroupsUsers.group_id == group_id).first()
if check_is_member is None:
new_relation = GroupsUsers(user_id=user_id,
group_id=group_id,
role_id=id_role_member)
db.session.add(new_relation)
db.session.commit()
return json({}, status=201)
else:
return json({"error_message": "Không tìm được số điện thoại này"},
status=520)
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
def getTaskFollower(request):
uid = auth.current_user(request)
if uid is not None:
page = request.args.get("page", None)
results_per_page = request.args.get("results_per_page", None)
offset = (int(page) - 1) * int(results_per_page)
result = []
list_task_id = []
follower_tasks = db.session.query(FollowerTask).filter(
FollowerTask.user_id == uid).all()
for follower_task in follower_tasks:
list_task_id.append(follower_task.task_id)
task_follower_not_done = db.session.query(Task).filter(
Task.id.in_(list_task_id), Task.group_id == None, Task.status != 1,
Task.deleted == False).order_by(Task.created_at.desc()).limit(
results_per_page).offset(offset).all()
task_follower_done = db.session.query(Task).filter(
Task.id.in_(list_task_id), Task.group_id == None, Task.status == 1,
Task.deleted == False).order_by(
Task.updated_at.desc()).limit(10).offset(offset).all()
for task in task_follower_not_done + task_follower_done:
result.append(to_dict(task))
return json({
"num_results": len(result),
"objects": result,
"page": page
})
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
def addMembers(request=None, group_id=None):
uid = auth.current_user(request)
if uid is not None:
data = request.json
id_role_member = db.session.query(
Role.id).filter(Role.role_name == "member").first()
for member in data['members']:
if member.get('id', None) is None:
new_user = createUser(member)
db.session.add(new_user)
db.session.flush()
new_relation = GroupsUsers(user_id=new_user.id,
group_id=data['group_id'],
role_id=id_role_member)
db.session.add(new_relation)
db.session.commit()
else:
new_relation = GroupsUsers(user_id=member['id'],
group_id=data['group_id'],
role_id=id_role_member)
db.session.add(new_relation)
db.session.commit()
return json({}, status=201)
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
def join_to_group(request=None):
uid = auth.current_user(request)
if uid is not None:
data = request.json
group_id = data.get('group_id')
user_id = data.get('user_id')
relation = db.session.query(GroupsUsers).filter(
GroupsUsers.group_id == group_id,
GroupsUsers.user_id == user_id).first()
if relation is not None:
db.session.delete(relation)
db.session.commit()
group_after_leave = db.session.query(Group.id,Group.group_name,Group.description)\
.filter(Group.id == group_id, Group.deleted == False).first()
group_after_leave = format_list_group([group_after_leave], uid)
return json(group_after_leave[0], status=201)
else:
return json({}, status=500)
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
def auth_func(request=None, **kw):
uid = auth.current_user(request)
print("auth_func")
print(uid)
if uid is None:
raise ServerError("API.py auth_func can not found uid")
async def user_current_user(request):
user_id = auth.current_user(request)
print(user_id)
user = User.query.filter(User.id == user_id).first()
if user is not None:
print(user.roles[0])
return json({
"id": user.id,
"user_name": user.user_name,
"full_name": user.full_name,
"employee_id": user.employee_id,
"role": user.roles[0].role_name
})
else:
return json(
{
"error_code": "NOT_FOUND",
"error_message": "User not found"
},
status=520)
return json({
"error_code": "UNKNOWN",
"error_message": "Unknown error"
},
status=520)
def getTaskCreate(request):
uid = auth.current_user(request)
if uid is not None:
page = request.args.get("page", None)
results_per_page = request.args.get("results_per_page", None)
offset = (int(page) - 1) * int(results_per_page)
tasks_created_not_done = db.session.query(Task).filter(
or_(Task.assignee_id != uid, Task.assignee_id == None),
Task.created_by == uid, Task.deleted == False, Task.status != 1,
Task.group_id == None).order_by(Task.created_at.desc()).limit(
results_per_page).offset(offset).all()
tasks_created_done = db.session.query(Task).filter(
or_(Task.assignee_id != uid, Task.assignee_id == None),
Task.created_by == uid, Task.deleted == False, Task.status == 1,
Task.group_id == None).order_by(
Task.updated_at.desc()).limit(10).offset(offset).all()
result = []
for task_create in tasks_created_not_done + tasks_created_done:
result.append(to_dict(task_create))
return json({
"num_results": len(result),
"objects": result,
"page": page
})
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
def getGroup(request=None):
uid = auth.current_user(request)
if uid is not None:
page = request.args.get("page", None) or 1
results_per_page = request.args.get("results_per_page", None) or 50
offset = (int(page) - 1) * int(results_per_page)
list_groups = db.session.query(Group.id,Group.group_name,Group.description)\
.join(GroupsUsers)\
.filter(GroupsUsers.user_id == uid,Group.deleted == False)\
.order_by(GroupsUsers.created_at.desc()).limit(results_per_page).offset(offset).all()
result = format_list_group(list_groups, uid)
return json({
"num_results": len(result),
"objects": result,
"page": page
})
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
def getGroup(request=None):
uid = auth.current_user(request)
if uid is not None:
page = request.args.get("page", None) or 1
results_per_page = request.args.get("results_per_page", 50)
offset = (int(page) - 1) * int(results_per_page)
filters = ujson.loads(request.args.get("q")).get("filters",
{}).get("$or", [])
search_args = []
if (len(filters) != 0):
for filter in filters:
for key, value in filter.items():
search_args.append(
getattr(Group,
key).ilike('%%%s%%' % value.get("$like")))
list_groups = db.session.query(Group.id,Group.group_name,Group.description)\
.filter(Group.deleted == False, Group.parent_id == None, or_(*search_args))\
.limit(results_per_page).offset(offset).all()
result = format_list_group(list_groups, uid)
return json({
"num_results": len(result),
"objects": result,
"page": page
})
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
async def current_user(request):
uid = auth.current_user(request)
if uid is not None:
user = db.session.query(User).filter(User.id == uid).first()
return user
else:
return None
def createChecklist(request=None, checklist_id=None):
uid = auth.current_user(request)
# print(createTaskInfo)
if uid is not None:
# checklist = request.json
checklist = db.session.query(Checklist).filter(
Checklist.id == checklist_id).first()
response = to_dict(checklist) or {}
tasks_info = db.session.query(TaskInfo).filter(
TaskInfo.checklist_id == checklist.id,
TaskInfo.deleted == False).all()
response['tasks_info'] = []
response['groups'] = []
response['shifts'] = []
for group in checklist.groups:
response['groups'].append(to_dict(group))
for shift in checklist.shifts:
response['shifts'].append(to_dict(shift))
for task_info in tasks_info:
task_info_add = {}
task_info_add = to_dict(task_info)
task_info_add['group'] = to_dict(task_info.group)
task_info_add['assignee'] = to_dict(task_info.assignee)
response['tasks_info'].append(task_info_add)
return json(response, status=200)
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
def checkContactHasBeenAccount(request=None):
uid = auth.current_user(request)
if uid is not None:
data = request.json
list_contact = data.get('contacts', [])
group = data.get('group', {})
# print(group)
list_contact_convert = convertListContact(list_contact)
list_phone = []
for contact in list_contact_convert:
list_phone.append(contact['phone'])
users_match = db.session.query(User).filter(
User.phone.in_(list_phone)).all()
# print(users_match)
response = []
for contact in list_contact_convert:
contact['is_member'] = False
for user in users_match:
if (user.phone == contact['phone']):
contact['display_name_server'] = user.display_name
contact['is_member'] = checkUserIsMember(user, group)
contact['id'] = str(user.id)
# print(contact)
response.append(contact)
return json(response)
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
def join_to_group(request=None):
uid = auth.current_user(request)
if uid is not None:
data = request.json
group_id = data.get('group_id')
user_id = data.get('user_id')
check_is_member = db.session.query(GroupsUsers.id).filter(
GroupsUsers.group_id == group_id,
GroupsUsers.user_id == user_id).first()
if check_is_member is None:
id_role_member = db.session.query(
Role.id).filter(Role.role_name == 'member').first()
new_relation = GroupsUsers(user_id=user_id,
group_id=group_id,
role_id=id_role_member)
db.session.add(new_relation)
db.session.commit()
group_after_join = db.session.query(Group.id,Group.group_name,Group.description)\
.filter(Group.id == group_id, Group.deleted == False).first()
group_after_join = format_list_group([group_after_join], uid)
return json(group_after_join[0], status=201)
else:
return json({}, status=500)
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
async def profile(request):
uid = auth.current_user(request)
if uid is not None:
response = text("uid:" + str(uid))
else:
response = text("There's a cookie up in this response")
#del response.cookies['_session']
return response
def auth_func(request=None, **kw):
user = auth.current_user(request)
if user is None:
return json(
{
"error_code": "SESSION_EXPIRED",
"error_message": "auth_func can not found uid"
},
status=520)
def get_task_info(request, task_info_id):
uid = auth.current_user(request)
if uid is not None:
task_info = db.session.query(TaskInfo).filter(TaskInfo.id == task_info_id, TaskInfo.deleted == False).first()
return json(to_dict(task_info),status=200)
else:
return json({
"error_code": "USER_NOT_FOUND",
"error_message":"USER_NOT_FOUND"
}, status = 520)
def putTask(request=None, task_id=None, **kw):
uid = auth.current_user(request)
data = request.json
if uid is not None:
in_relation_ids = []
for follower in data['followers']:
# CHECK EXISTS
check_follower = db.session.query(FollowerTask).filter(FollowerTask.task_id == data['id'],\
FollowerTask.user_id == follower['id']).first()
# is_relation_exist = db.session.query(literal(True)).filter(check_follower.exists()).scalar()
if check_follower is not None:
in_relation_ids.append(check_follower.id)
pass
else:
new_relation = FollowerTask(
user_id=follower['id'],
task_id=data['id'],
note=data['note'] or None,
)
db.session.add(new_relation)
db.session.flush()
in_relation_ids.append(new_relation.id)
# DELETE ALL OTHER RELATIONS NOT IN in_relation_ids
db.session.query(FollowerTask).filter(
~FollowerTask.id.in_(in_relation_ids),
FollowerTask.task_id == data['id']).delete(
synchronize_session=False)
# del data['task_info']
# del data['followers']
# assignee = db.session.query(User).filter(User.id == data['assignee']['id']).first()
try:
data['assignee'] = db.session.query(User).filter(
User.id == data['assignee']['id']).first()
except:
pass
task_update = db.session.query(Task).filter(Task.id == task_id).first()
# task_update.assignee = assignee
for key in data.keys():
if hasattr(task_update,
key) and not isinstance(data[key], (dict, list)):
setattr(task_update, key, data[key])
# task_update.assignee = assignee
db.session.add(task_update)
db.session.commit()
return json(to_dict(task_update), status=200)
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
async def user_logout(request):
uid = auth.current_user(request)
params = request.json
# print(params)
# user = db.session.query(User).filter(User.id == int(current_user)).first()
user_update = db.session.query(User).filter(User.id == uid).first()
if user_update is not None:
user_update.group_last_access_id = params['group_last_access_id']
db.session.commit()
auth.logout_user(request)
return json({})
def pre_post_todo_schedule(request=None, Model=None, result=None, **kw):
param = request.json
currentUser = auth.current_user(request)
if (currentUser is None):
return json(
{
"error_code": "SESSION_EXPIRED",
"error_message": "Hết phiên làm việc, vui lòng đăng nhập lại!"
},
status=520)
if result['id'] is not None:
list_data_before_commit = []
start_time_working = result['start_time_working']
end_time_working = result['end_time_working']
todo_schedule_id = result['id']
for index in range(0, len(result["todoscheduledetail"])):
todoschedule_detail = TodoScheduleDetail.query.filter(
TodoScheduleDetail.id == result['todoscheduledetail'][index]
['id']).first()
todo_list = todoschedule_detail.todo
employee_list = todoschedule_detail.employee
for employee in employee_list:
for todo in todo_list:
data_before_commit = {'todo_schedule_id':todo_schedule_id,\
'employee_id':employee.id,\
'employee_name':employee.name,'employee' : employee,'todo_id':todo.id,\
'todo_name':todo.todo_name,'todo' : todo,\
'day_working':todoschedule_detail.day_working,\
'time_working':todoschedule_detail.time_working}
list_data_before_commit.append(data_before_commit)
group_data_before_commit = group_list_data_follow_employee(
list_data_before_commit)
for data_commit in list_data_before_commit:
employee_assign = find_employee_be_assign(group_data_before_commit)
data_add = EmployeeRelTodo(
start_time_working=start_time_working,\
end_time_working = end_time_working,\
todo_schedule_id = todo_schedule_id,\
day_working=data_commit['day_working'],time_working=data_commit['time_working'],\
employee_id=data_commit['employee_id'],employee_name=data_commit['employee_name'],\
employee = data_commit['employee'],employee_assign_name = employee_assign.name,\
employee_assign_id = employee_assign.id,employee_assign=employee_assign,\
todo_id = data_commit['todo_id'],todo_name = data_commit['todo_name'],\
todo = data_commit['todo'])
group_data_before_commit = group_list_data_after_find(employee_assign,\
data_commit['todo'].level_diffcult,group_data_before_commit)
db.session.add(data_add)
db.session.commit()
def getSigleGroup(request=None, group_id=None):
uid = auth.current_user(request)
if uid is not None:
group = db.session.query(
Group.id, Group.group_name,
Group.description).filter(Group.id == group_id).first()
result = {}
result['id'] = str(group[0]) or None
result['group_name'] = group[1] or None
result['description'] = group[2] or None
role_member = db.session.query(Role).filter(
Role.role_name == "member").first()
total_members = db.session.query(
func.count(GroupsUsers.user_id)).filter(
GroupsUsers.group_id == group[0],
GroupsUsers.role_id == role_member.id).scalar()
result['total_members'] = total_members
total_tasks_info = db.session.query(func.count(
TaskInfo.id)).filter(TaskInfo.group_id == result['id']).scalar()
result['total_tasks_info'] = total_tasks_info
role_admin = db.session.query(Role).filter(
Role.role_name == 'admin').first()
total_admins = db.session.query(
func.count(GroupsUsers.user_id)).filter(
GroupsUsers.group_id == group[0],
GroupsUsers.role_id == role_admin.id).scalar()
result['total_admins'] = total_admins
first_five_admins = db.session.query(User.id,User.phone,User.email,User.display_name).join(GroupsUsers)\
.filter(GroupsUsers.group_id == group[0],GroupsUsers.role_id == role_admin.id).order_by(GroupsUsers.created_at.desc()).limit(5).all()
result['first_five_admins'] = []
for admin in first_five_admins:
admin_add = {
'id': str(admin[0]),
'phone': admin[1],
'email': admin[2],
'display_name': admin[3]
}
if admin_add['id'] == uid:
result['first_five_admins'].insert(0, admin_add)
else:
result['first_five_admins'].append(admin_add)
return json(result, status=200)
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
async def user_logout(request):
current_user = auth.current_user(request)
user = db.session.query(User).filter(User.id == int(current_user)).first()
try:
set_logout_for_salary(user)
# salary = db.session.query(Salary).filter(Salary.id_employee==17).first()
# print("11111111111",salary)
user.employee.status = 'offline'
db.session.commit()
except:
pass
auth.logout_user(request)
return json({})
async def get_current_user(request):
error_msg = None
uid = auth.current_user(request)
if uid is not None:
user = db.session.query(User).filter(User.id == uid).first()
user_info = response_userinfo(user)
return json(user_info)
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
def postTaskInfo(request=None, data=None, Model=None):
uid = auth.current_user(request)
if uid is not None:
task_info = request.json
task_info = createTaskInfo(task_info,uid)
response = to_dict(task_info)
response['group'] = to_dict(task_info.group)
print(response['group'])
return json(response,status=201)
else:
return json({
"error_code": "USER_NOT_FOUND",
"error_message":"USER_NOT_FOUND"
}, status = 520)
def setGroupLastAccess(request=None, group_id=None):
uid = auth.current_user(request)
if uid is not None:
user_update = db.session.query(User).filter(User.id == uid).first()
user_update.group_last_access_id = group_id
db.session.add(user_update)
db.session.commit()
return json({}, status=200)
else:
return json(
{
"error_code": "USER_NOT_FOUND",
"error_message": "USER_NOT_FOUND"
},
status=520)
