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)