def __init__(self, mongo):
self.mongo = mongo
self.solution_model = solution_model(self.mongo)
self.workflow_model = workflow_model(self.mongo)
self.file_model = file_model(self.mongo)
self.user_model = user_model(self.mongo)
self.dding = Dding(self.mongo)
def __init__(self, mongo):
self.mongo = mongo
self.department_model = department_model(self.mongo)
self.user_model = user_model(self.mongo)
self.dding = Dding(self.mongo)
self.user_service = user_service(self.mongo)
self.file_model = file_model(self.mongo)
class Department(object):
""" User Service Class"""
def __init__(self, mongo):
self.mongo = mongo
self.dding = Dding(self.mongo)
self.department_model = department_model(self.mongo)
self.user_model = user_model(self.mongo)
def list_all(self):
""" list all departments """
data = self.department_model.list_all()
return data, 0, ''
def list_tree(self):
""" list all tree """
data = self.department_model.list_tree()
return data, 0, ''
def create(self, name, parentid, create_dept_group):
""" create department """
parent_result = self.department_model.find_id(parentid)
dd_result = self.dding.create_department(name, parent_result['did'],
create_dept_group)
if not dd_result['errcode']:
return self.department_model.add(dd_result['id'], name,
parentid), 0, ''
else:
return "", dd_result['errcode'], dd_result['errmsg']
def update(self, _id, name, parentid, manager):
""" update department """
department = self.department_model.find_id(_id)
parent = self.department_model.find_id(parentid)
if manager:
user = self.user_model.find_id(manager)
if user:
manager = user['userid']
if not department:
return "", 1, ""
dd_result = self.dding.update_department(department['did'], name,
parent['did'], manager)
if not dd_result['errcode']:
return self.department_model.update(_id, name, parentid,
manager), 0, ''
else:
return "", dd_result['errcode'], dd_result['errmsg']
def remove(self, _id):
""" remove department """
department = self.department_model.find_id(_id)
if not department:
return "", 1, ""
dd_result = self.dding.delete_department(department['did'])
if not dd_result['errcode']:
self.department_model.remove(_id)
return "", 0, ""
else:
return "", dd_result['errcode'], dd_result['errmsg']
class Service(object):
""" DDing Service Class"""
def __init__(self, mongo):
self.mongo = mongo
self.dding = Dding(self.mongo)
def get_jsapi_signature(self):
""" Get JS-API Signature """
result = self.dding.get_jsapi_ticket()
if result['errcode']:
return {"token":''}, result['errcode'], result['errmsg']
else:
str_sign = ""
sign = {
"noncestr" : "a5se512436rqwuschsew8r7t23462783",
"jsapi_ticket" : result['ticket'],
"timestamp" : int(time.time()),
"url" : "//okrs.tap4fun.com/dingding",
}
for key, value in sorted(sign.items()):
if str_sign:
str_sign += "&{}={}".format(key, value)
else:
str_sign = "{}={}".format(key, value)
result = {"signatue":hashlib.sha1(str_sign).hexdigest(),
"url": sign["url"],
"noncestr":sign["noncestr"],
"timestamp":sign["timestamp"]}
return result, 0, "success"
class Workflow(object):
""" Workflow Service Class"""
def __init__(self, mongo):
self.mongo = mongo
self.solution_model = solution_model(self.mongo)
self.workflow_model = workflow_model(self.mongo)
self.file_model = file_model(self.mongo)
self.user_model = user_model(self.mongo)
self.dding = Dding(self.mongo)
def list_all(self):
""" list all workflow """
data = self.solution_model.list_all()
return data, 0, ''
def add(self, solution_id, fields):
now = datetime.datetime.now()
token = request.cookies.get('token')
creator = self.user_model.find_user_token(token)
solution = self.solution_model.find(solution_id)
nodes = self.flow_generator(solution['flow'], fields, '0',
creator['_id'])
copyto_users = []
next_user = []
for user in solution['copyto']:
usermodel = self.user_model.find_id(user)
copyto_users.append(usermodel['user_id'])
usermodel = self.user_model.find_id(nodes[0])
next_user.append(usermodel['user_id'])
self.dding.send_link(
copyto_users, "审批提醒",
creator['name'] + "于" + now.strftime("%Y-%m-%d %H:%M:%S") + "发起了" +
solution['name'] + "审批并抄送您。",
"http://office.tap4fun.com/hrs/jump?url=" +
quote("http://office.tap4fun.com/workflow/copyto"))
self.dding.send_link(
next_user, "审批提醒",
creator['name'] + "于" + now.strftime("%Y-%m-%d %H:%M:%S") + "发起了" +
solution['name'] + "审批，等待您的审批。",
"http://office.tap4fun.com/hrs/jump?url=" +
quote("http://office.tap4fun.com/workflow/pending"))
return self.workflow_model.add(solution_id, fields, nodes,
creator['_id']), 0, ''
def flow_generator(self, flow, fields, parentNode, creator):
current = {}
result = []
for node in flow:
if node['source'] == parentNode and node['type'] == 'action':
current = node
break
elif node['source'] == parentNode and node['type'] == 'condition':
current = node
break
if not current:
return []
if current['type'] == 'action':
result += self.user_generator(current, creator)
result += self.flow_generator(flow, fields, current['id'], creator)
elif current['type'] == 'condition':
final_node = {}
for index, node in enumerate(flow):
if node['source'] == current['source'] and node[
'fieldType'] == 'select':
if fields[node['namespace']] in node['options']:
final_node = node
break
if node['source'] == current['source'] and node[
'fieldType'] == 'number':
if node['operator'] == '>' and fields[
node['namespace']] > node['fillNumber']:
final_node = node
break
if node['operator'] == '=' and fields[
node['namespace']] == node['fillNumber']:
final_node = node
break
if node['operator'] == '<' and fields[
node['namespace']] < node['fillNumber']:
final_node = node
break
if node['operator'] == '>=' and fields[
node['namespace']] >= node['fillNumber']:
final_node = node
break
if node['operator'] == '<=' and fields[
node['namespace']] <= node['fillNumber']:
final_node = node
break
if node['source'] == current['source'] and node[
'fieldType'] == 'date':
if fields[node['namespace']]['dateType'] == 'dateRange':
start = libs.str_to_utc(
fields[node['namespace']]['value'][0], "%Y-%m-%d")
end = libs.str_to_utc(
fields[node['namespace']]['value'][1],
"%Y-%m-%d") + datetime.timedelta(days=1)
current_minutes = (end - start).days * 24 * 60
if node['cycle_day'] == -1:
last_cycle_time_arr = flow[
index - 1]['cycle_time'].split(':')
last_cycle_minutes = flow[
index - 1]['cycle_day'] * 24 * 60 + int(
last_cycle_time_arr[0]) * 60 + int(
last_cycle_time_arr[1])
if current_minutes > last_cycle_minutes:
final_node = node
break
else:
cycle_time_arr = node['cycle_time'].split(':')
cycle_minutes = node['cycle_day'] * 24 * 60 + int(
cycle_time_arr[0]) * 60 + int(
cycle_time_arr[1])
if index == 0:
if current_minutes > 0 and current_minutes <= cycle_minutes:
final_node = node
break
else:
last_cycle_time_arr = flow[
index - 1]['cycle_time'].split(':')
last_cycle_minutes = flow[
index - 1]['cycle_day'] * 24 * 60 + int(
last_cycle_time_arr[0]) * 60 + int(
last_cycle_time_arr[1])
if current_minutes > last_cycle_minutes and current_minutes <= cycle_minutes:
final_node = node
break
elif fields[node['namespace']]['dateType'] == 'timeRange':
start = libs.str_to_utc(
fields[node['namespace']]['value'][0],
"%Y-%m-%d %H:%M")
end = libs.str_to_utc(
fields[node['namespace']]['value'][1],
"%Y-%m-%d %H:%M") + datetime.timedelta(minutes=1)
current_minutes = (end - start).seconds / 60
if node['cycle_day'] == -1:
last_cycle_time_arr = flow[
index - 1]['cycle_time'].split(':')
last_cycle_minutes = flow[
index - 1]['cycle_day'] * 24 * 60 + int(
last_cycle_time_arr[0]) * 60 + int(
last_cycle_time_arr[1])
if current_minutes > last_cycle_minutes:
final_node = node
break
else:
cycle_time_arr = node['cycle_time'].split(':')
cycle_minutes = node['cycle_day'] * 24 * 60 + int(
cycle_time_arr[0]) * 60 + int(
cycle_time_arr[1])
if index == 0:
if current_minutes > 0 and current_minutes <= cycle_minutes:
final_node = node
break
else:
last_cycle_time_arr = flow[
index - 1]['cycle_time'].split(':')
last_cycle_minutes = flow[
index - 1]['cycle_day'] * 24 * 60 + int(
last_cycle_time_arr[0]) * 60 + int(
last_cycle_time_arr[1])
if current_minutes > last_cycle_minutes and current_minutes <= cycle_minutes:
final_node = node
break
result += self.flow_generator(flow, fields, final_node['id'],
creator)
return result
def time_convert_to_minutes(self, days, time_str):
time_str_arr = time_str.split(':')
total = (days * 24 * 60) + int(time_str_arr[0]) * 60 + int(
time_str_arr[1])
return total
def user_generator(self, node, creator):
user = {}
result = []
if node['approvalWay'] == 3:
return [node['approvalObject']['id']]
if node['approvedObject'] == '0':
user = self.user_model.find_id(creator)
else:
user = self.user_model.find_id(node['approvedObject'])
if not user:
return result
users = self._user_generator(user, node['approvalWay'], [])
if node['level'] == 1 and users:
for index in range(len(users)):
if node['selectLevel'] <= (len(users) - index):
result.append(users[index])
elif node['level'] == 2 and users:
for index in range(len(users)):
if len(result) >= node['selectLevel']:
break
result.append(users[index])
elif node['level'] == 3 and users:
if len(users) >= node['selectLevel']:
position = len(users) - node['selectLevel']
if position >= 0:
result.append(users[position])
return result
def _user_generator(self, currentUser, _type, users):
if _type == 1 and currentUser['adminreport']:
users.append(currentUser['adminreport'][0])
user = self.user_model.find_id(currentUser['adminreport'][0])
if user:
users = self._user_generator(user, _type, users)
elif _type == 2 and currentUser['workreport']:
users.append(currentUser['workreport'][0])
user = self.user_model.find_id(currentUser['workreport'][0])
if user:
users = self._user_generator(user, _type, users)
return users
def find_own_workflow(self, status, pagination):
result = {}
cursor, result['count'] = self.workflow_model.find_own_workflow(
status, 20, pagination)
result['list'] = []
for item in cursor:
users = []
solution = self.solution_model.find(item['solution_id'])
item['solution'] = solution
item['next_user'] = self.user_model.find_id(item['next'])
item['creator_user'] = self.user_model.find_id(item['creator'])
for userid in item['member']:
users.append(self.user_model.find_id(userid))
item['users'] = users
for log in item['operation_log']:
if log['type'] == 'comment':
log['picture_detail'] = []
log['attachment_detail'] = []
for picture in log['picture']:
log['picture_detail'].append(
self.file_model.find(picture))
for attachment in log['attachment']:
log['attachment_detail'].append(
self.file_model.find(attachment))
result['list'].append(item)
return result, 0, ""
def find_own_pending_workflow(self, pagination):
result = {}
cursor, result[
'count'] = self.workflow_model.find_own_pending_workflow(
20, pagination)
result['list'] = []
for item in cursor:
users = []
solution = self.solution_model.find(item['solution_id'])
item['solution'] = solution
item['next_user'] = self.user_model.find_id(item['next'])
item['creator_user'] = self.user_model.find_id(item['creator'])
for userid in item['member']:
users.append(self.user_model.find_id(userid))
item['users'] = users
for log in item['operation_log']:
if log['type'] == 'comment':
log['picture_detail'] = []
log['attachment_detail'] = []
for picture in log['picture']:
log['picture_detail'].append(
self.file_model.find(picture))
for attachment in log['attachment']:
log['attachment_detail'].append(
self.file_model.find(attachment))
result['list'].append(item)
return result, 0, ""
def find_own_done_workflow(self, pagination):
result = {}
cursor, result['count'] = self.workflow_model.find_own_done_workflow(
20, pagination)
result['list'] = []
for item in cursor:
users = []
solution = self.solution_model.find(item['solution_id'])
item['solution'] = solution
item['next_user'] = self.user_model.find_id(item['next'])
item['creator_user'] = self.user_model.find_id(item['creator'])
for userid in item['member']:
users.append(self.user_model.find_id(userid))
item['users'] = users
for log in item['operation_log']:
if log['type'] == 'comment':
log['picture_detail'] = []
log['attachment_detail'] = []
for picture in log['picture']:
log['picture_detail'].append(
self.file_model.find(picture))
for attachment in log['attachment']:
log['attachment_detail'].append(
self.file_model.find(attachment))
result['list'].append(item)
return result, 0, ""
def find_own_copyto_workflow(self, pagination):
result = {}
cursor, result['count'] = self.workflow_model.find_own_copyto_workflow(
20, pagination)
result['list'] = []
for item in cursor:
users = []
solution = self.solution_model.find(item['solution_id'])
item['solution'] = solution
item['next_user'] = self.user_model.find_id(item['next'])
item['creator_user'] = self.user_model.find_id(item['creator'])
for userid in item['member']:
users.append(self.user_model.find_id(userid))
item['users'] = users
for log in item['operation_log']:
if log['type'] == 'comment':
log['picture_detail'] = []
log['attachment_detail'] = []
for picture in log['picture']:
log['picture_detail'].append(
self.file_model.find(picture))
for attachment in log['attachment']:
log['attachment_detail'].append(
self.file_model.find(attachment))
result['list'].append(item)
return result, 0, ""
def cancel(self, _id):
result = self.workflow_model.cancel(_id)
return result, 0, ""
def audit(self, _id, status, content):
now = datetime.datetime.now()
result = self.workflow_model.audit(_id, status, content)
creator = self.user_model.find_id(result['creator'])
solution = self.solution_model.find(result['solution_id'])
next_user = self.user_model.find_id(result['next'])
if result['status'] == 0:
self.dding.send_link(
[next_user['user_id']], "审批提醒", creator['name'] + "于" +
result['creation_time'].strftime("%Y-%m-%d %H:%M:%S") + "发起了" +
solution['name'] + "审批，等待您的审批。",
"http://office.tap4fun.com/hrs/jump?url=" +
quote("http://office.tap4fun.com/workflow/pending"))
elif result['status'] == 1:
self.dding.send_link(
[creator['user_id']], "审批提醒",
"您发起的" + solution['name'] + "审批，已于" +
result['end_time'].strftime("%Y-%m-%d %H:%M:%S") + "通过。",
"http://office.tap4fun.com/hrs/jump?url=" +
quote("http://office.tap4fun.com/workflow/history"))
elif result['status'] == 2:
self.dding.send_link(
[creator['user_id']], "审批提醒",
"您发起的" + solution['name'] + "审批，已于" +
result['end_time'].strftime("%Y-%m-%d %H:%M:%S") + "被拒绝。",
"http://office.tap4fun.com/hrs/jump?url=" +
quote("http://office.tap4fun.com/workflow/history"))
return {}, 0, ""
def comment(self, _id, content, picture, attachment):
item = self.workflow_model.comment(_id, content, picture, attachment)
users = []
solution = self.solution_model.find(item['solution_id'])
item['solution'] = solution
item['next_user'] = self.user_model.find_id(item['next'])
item['creator_user'] = self.user_model.find_id(item['creator'])
for userid in item['member']:
users.append(self.user_model.find_id(userid))
item['users'] = users
for log in item['operation_log']:
if log['type'] == 'comment':
log['picture_detail'] = []
log['attachment_detail'] = []
for picture in log['picture']:
log['picture_detail'].append(self.file_model.find(picture))
for attachment in log['attachment']:
log['attachment_detail'].append(
self.file_model.find(attachment))
return item, 0, ""
class Synch(object):
""" Organization Synch Class"""
def __init__(self, mongo):
self.mongo = mongo
self.department_model = department_model(self.mongo)
self.user_model = user_model(self.mongo)
self.dding = Dding(self.mongo)
self.user_service = user_service(self.mongo)
self.file_model = file_model(self.mongo)
def synch(self):
""" Launch Synch """
result = self.dding.get_department()
self._add(result['department'], 0, 0)
return {}, 0, "success"
def synch_leader(self):
result = self.department_model.list_all()
for department in result:
detail = self.dding.get_department_detail(department['did'])
user = self.user_model.find_user_id(detail['deptManagerUseridList'])
self.mongo.db.department.update(
{
"did": department['did']
},
{
'$set':
{
'managers':[user['_id']]
}
})
def _add(self, departments, parentid, parentdid):
""" add department """
for department in departments:
exists = False
if 'parentid' in department.keys():
exists = True
if not parentid and not exists:
result = self.department_model.add(department['id'], department['name'], parentid)
self._add(departments, result['_id'], result['did'])
else:
if exists:
if department['parentid'] == parentdid:
result = self.department_model.add(department['id'],
department['name'],
parentid)
self._add(departments, result['_id'], department['id'])
def synch_user(self):
""" import """
with open('/Users/yangyunbo/Desktop/import.csv') as f:
f_csv = csv.reader(f)
headers = next(f_csv)
for row in f_csv:
data = {}
graduationdate = ''
regularizationdate = ''
birthday = ''
entrydate = ''
if row[18]:
graduationdate = libs.str_to_utc(row[18], "%Y-%m-%d")
if row[6]:
regularizationdate = libs.str_to_utc(row[6], "%Y-%m-%d")
if row[10]:
birthday = libs.str_to_utc(row[10], "%Y-%m-%d")
if row[7]:
entrydate = libs.str_to_utc(row[7], "%Y-%m-%d")
if row[5] == '实习生':
data = {
"_id": ObjectId(),
"member_id": row[1],
"user_id": '',
'login_record':[],
'permission':[],
'group':0,
'status':'admitted',
'insurance': '',
'taxes': '',
'fund': '',
'salary': ObjectId('58ec7a20cf30a56388401be9'),
'salaries':[
{
"name": "基本薪资（日薪）",
"value": float(row[40]),
"salary_id": ObjectId("58f08453cf30a55d48a2f0c8")
}
],
'firstworkdate':'',
'major':row[16],
'selfie':[],
'adminreport':[],
'hukouintro':[],
'universitytype':row[15],
'joblevel':row[28],
'education':row[17],
'bankcardnumber':row[35],
'jobseries':row[29],
'depositbank':row[34],
'placeofpermanent':row[12],
'backuptel':'',
'contactname':row[36],
'department':[],
'type':row[5],
'email':row[3],
'idcopyfront':[],
'graduationdate':graduationdate,
'relationship':row[37],
'workreport':[],
'position_level':row[31],
'regularizationdate':regularizationdate,
'birthday':birthday,
'address':row[13],
'certificatetype':row[8],
'name':row[0],
'salary_level':row[32],
'entrydate':entrydate,
'mobilephone':row[4],
'gender':row[2],
'university':row[14],
'academiccertificate':[],
'idnumber':row[9],
'contacttel':row[38],
'subordinate_companies':row[21],
'marriage':row[11],
'workplace':row[20],
'jobcategory':row[26],
'position':row[27],
'degreecertificate':[],
'employeemanual': True
}
else:
taxesid = ""
if row[5] == '普通员工':
taxesid = "58ec797acf30a56388401be8"
else:
taxesid = "58ec800ccf30a56388401bee"
data = {
"_id": ObjectId(),
"member_id": row[1],
"user_id": '',
'login_record':[],
'permission':[],
'group':"0",
'status':'admitted',
'insurance': ObjectId('58edbcdfcf30a5a72b061903'),
'taxes': ObjectId(taxesid),
'fund': ObjectId('58ec7b56cf30a56388401bec'),
'salary': ObjectId('58f0843dcf30a55d48a2f0c6'),
'salaries':[
{
"name": "基本薪资",
"value": float(row[40]),
"salary_id": ObjectId("58f0843dcf30a55d48a2f0c2")
},
{
"name": "岗位薪资",
"value": float(row[41]),
"salary_id": ObjectId("58f0843dcf30a55d48a2f0c3")
}
],
'firstworkdate':'',
'major':row[16],
'selfie':[],
'adminreport':[],
'hukouintro':[],
'universitytype':row[15],
'joblevel':row[28],
'education':row[17],
'bankcardnumber':row[35],
'jobseries':row[29],
'depositbank':row[34],
'placeofpermanent':row[12],
'backuptel':'',
'contactname':row[36],
'department':[],
'type':row[5],
'email':row[3],
'idcopyfront':[],
'graduationdate':graduationdate,
'relationship':row[37],
'workreport':[],
'position_level':row[31],
'regularizationdate':regularizationdate,
'birthday':birthday,
'address':row[13],
'certificatetype':row[8],
'name':row[0],
'salary_level':row[32],
'entrydate':entrydate,
'mobilephone':row[4],
'gender':row[2],
'university':row[14],
'academiccertificate':[],
'idnumber':row[9],
'contacttel':row[38],
'subordinate_companies':row[21],
'marriage':row[11],
'workplace':row[20],
'jobcategory':row[26],
'position':row[27],
'degreecertificate':[],
'employeemanual': True
}
self.mongo.db.user.insert_one(data)
def synch_dd(self):
departments = self.department_model.list_all()
for department in departments:
users = self.dding.get_users_detail(department['did'])
for user in users['userlist']:
self.mongo.db.user.update(
{
"name": user['name']
},
{
'$set':
{
'user_id':user['userid']
}
})
self.mongo.db.user.update(
{
"name": user['name']
},
{
'$push':
{
'department':
{
"value": str(department['_id']),
"label": department['name']
}
}
})
def synch_report(self):
with open('/Users/yangyunbo/Desktop/import.csv') as f:
f_csv = csv.reader(f)
headers = next(f_csv)
for row in f_csv:
if not row[30]:
continue
adminreport_result = self.mongo.db.user.find_one({"name":row[30]})
workreport_result = self.mongo.db.user.find_one({"name":row[33]})
print row[0]
print row[30]
print row[33]
print adminreport_result
print workreport_result
self.mongo.db.user.update(
{
"name": row[0]
},
{
'$set':
{
'adminreport':[str(adminreport_result['_id'])],
'workreport':[str(workreport_result['_id'])]
}
})
def synch_avatar(self):
# users = self.user_model.list_all()
# for user in users:
# result = self.dding.get_user_detail(user['user_id'])
# if "avatar" in result.keys():
# file_result = self._load(result['avatar'])
# if not file_result:
# continue
# self.mongo.db.user.update(
# {
# "user_id": result['userid']
# },
# {
# '$set':
# {
# 'selfie':[]
# }
# })
# self.mongo.db.user.update(
# {
# "user_id": result['userid']
# },
# {
# '$push':
# {
# 'selfie':file_result['_id']
# }
# })
# else:
# print result
result = self.mongo.db.file.find()
for file in result:
self.mongo.db.file.update(
{
"_id": file['_id']
},
{
'$set':
{
'filename':file['filename'].replace('attachment/','')
}
})
def _load(self, avatar):
""" download database """
filename = config.disk_path+"/attachment/"+hashlib.md5(avatar).hexdigest()
try:
read = requests.get(avatar, stream=True)
database = open(filename, "wb")
for chunk in read.iter_content(chunk_size=512):
if chunk:
database.write(chunk)
database.close()
result = self.file_model.add(filename+".jpg", ".jpg", filename)
return result
except Exception, err:
print err
return ''
class User(object):
""" User Service Class"""
def __init__(self, mongo):
self.mongo = mongo
self.department_model = department_model(self.mongo)
self.user_model = user_model(self.mongo)
self.module_model = module_model(self.mongo)
self.menu_model = menu_model(self.mongo)
self.field_model = field_model(self.mongo)
self.file_model = file_model(self.mongo)
self.dding = Dding(self.mongo)
self.uac_service = uac_service(self.mongo)
def auth(self, ticket):
""" auth with gmail """
result, code, message = self.uac_service.validate(ticket)
if not code:
token = self.user_model.authorized_email(result['email'])
expiretime = datetime.datetime.now()
expiretime = expiretime + datetime.timedelta(days=7)
data = {"token": token, "expiretime": expiretime}
return data, 0, "", "token", token, expiretime, True
else:
return result, 1, message, "", "", "", False
def authorizing(self, code):
""" authorizing user """
result = self.dding.get_user_info(code)
if not result['errcode']:
token = self.user_model.authorized_user_id(result['userid'])
expiretime = datetime.datetime.now()
expiretime = expiretime + datetime.timedelta(days=7)
data = {"token": token, "expiretime": expiretime}
return data, result[
'errcode'], "", "token", token, expiretime, True
else:
return {}, result['errcode'], result['errmsg'], "", "", "", False
def verify(self):
""" verify cookie """
token = request.cookies.get('token')
code = 0
message = ""
if not token:
code = 1
message = "invalid token"
else:
if self.user_model.verify(token):
code = 0
message = "valid token"
else:
code = 1
message = "invalid token"
return {}, code, message
def get_current(self):
""" get current user information """
token = request.cookies.get('token')
data = {}
code = 0
message = ""
if not token:
code = 1
message = "invalid token"
else:
data = self.user_model.find_user_token(token)
if not data:
code = 1
message = "invalid token"
group_result = self.field_model.list_group()
group_list = []
for group in group_result:
group_list.append(group)
for group in group_list:
for field in group['fields']:
if field['type'] == 'file':
files = []
for file in data[field['namespace']]:
files.append(self.file_model.find(file))
data[field['namespace']] = files
if field['type'] == 'date':
if field['namespace'] in data:
date = data[field['namespace']]
if date:
data[field['namespace']] = libs.utc_to_local(
date).strftime("%Y-%m-%d")
return data, code, message
def list_all(self):
""" list all users """
data = self.user_model.list_all()
return data, 0, ''
def list_user(self, condition, pagination):
""" list users """
group_result = self.field_model.list_group()
result = {}
for key in condition.keys():
if not condition[key]:
del condition[key]
if condition.has_key('regularizationdate'):
if bool(int(condition['regularizationdate'])):
condition['regularizationdate'] = {"$ne": ''}
else:
condition['regularizationdate'] = ""
if condition.has_key('department'):
temp_department = []
for department_id in condition['department']:
temp_department.append(
{"department.value": department_id['value']})
condition['$or'] = temp_department
del condition['department']
user_list = self.user_model.list_user(condition, {"loginrecord": 0},
40, pagination)
result['data'] = []
# set file default value
group_list = []
for group in group_result:
group_list.append(group)
for user in user_list:
for group in group_list:
for field in group['fields']:
if field['type'] == 'file':
files = []
for file in user[field['namespace']]:
files.append(self.file_model.find(file))
user[field['namespace']] = files
if field['type'] == 'date':
if field['namespace'] in user:
date = user[field['namespace']]
if date:
user[field['namespace']] = libs.utc_to_local(
date).strftime("%Y-%m-%d")
result['data'].append(user)
result['count'] = self.user_model.count_user(condition)
return result, 0, ''
def list_name(self, keywords):
""" list users """
result = self.user_model.list_name(keywords)
return result, 0, ''
def update_group(self, _id, group):
""" list all users """
data = self.user_model.update_group(_id, group)
self._update_permission_group(_id, group)
return data, 0, ''
def get_menus(self):
""" get current user menus """
ids = []
token = request.cookies.get('token')
data = {}
menus = []
code = 0
message = ""
if not token:
code = 1
message = "invalid token"
else:
data = self.user_model.find_user_token(token)
if not data:
code = 1
message = "invalid token"
if data:
if data['group'] == '2':
result = self.menu_model.list_all()
for menu in result:
menus.append(menu)
else:
for permission in data['permission']:
if 'menus' in permission.keys():
for menu in permission['menus']:
ids.append(str(menu['menuid']))
result = self.menu_model.list_sub_ids(ids)
for menu in result:
sub_menu = []
for sub in menu['sub']:
for _id in ids:
if str(_id) == str(sub['_id']):
sub_menu.append(sub)
menu['sub'] = sub_menu
menus.append(menu)
return menus, code, message
def _update_permission_group(self, _id, group):
""" update user permission by group """
permission = []
modules = []
if group == '0':
modules = self.module_model.list_permission('0')
elif group == '1':
modules = self.module_model.list_permission('1')
elif group == '2':
modules = self.module_model.list_permission('2')
for module in modules:
menus = self.menu_model.list(module['_id'])
menu_permission = []
for menu in menus:
for sub in menu['sub']:
if group == '0':
if sub['permission'] == '0':
menu_permission.append({
"menuid": sub['_id'],
"permission": '0'
})
elif group == '1':
if sub['permission'] == '0' or sub['permission'] == '1':
menu_permission.append({
"menuid": sub['_id'],
"permission": '1'
})
elif group == '2':
menu_permission.append({
"menuid": sub['_id'],
"permission": '1'
})
permission.append({
"moduleid": module['_id'],
"menus": menu_permission
})
if group == '2':
permission = []
self.user_model.update_permission(_id, permission)
def update_permission(self, _id, permissions):
""" update user permission """
code = 0
message = ""
user_obj = self.user_model.find_id(_id)
permissions = json.loads(permissions)
if not user_obj:
code = 1
message = 'Invalid userid'
for permission in permissions:
module = self.module_model.find(permission['moduleid']['$oid'])
permission['moduleid'] = ObjectId(permission['moduleid']['$oid'])
if not module:
code = 2
message = 'Invalid module id'
if user_obj['group'] == '0' and module['permission'] != "0":
code = 3
message = 'Module access denied'
if user_obj['group'] == '1' and module['permission'] == "2":
code = 3
message = 'Module access denied'
if 'menus' in permission.keys():
for menu in permission['menus']:
menu_obj = self.menu_model.find_sub(menu['menuid']['$oid'])
menu['menuid'] = ObjectId(menu['menuid']['$oid'])
if not menu_obj:
code = 4
message = 'Invalid menu id'
if user_obj['group'] == '0' and menu_obj['sub'][0][
'permission'] != "0":
code = 5
message = 'Menu access denied'
if user_obj['group'] == '1' and menu_obj['sub'][0][
'permission'] == "2":
code = 5
message = 'Menu access denied'
if not code:
self.user_model.update_permission(_id, permissions)
return {}, code, message
def find_id(self, _id):
""" find user by id """
return self.user_model.find_id(_id), 0, ""
def entry(self, custom_field, insurance, taxes, fund, salary, salaries):
""" new member entry """
code = 0
message = ""
status = "passed"
field_group = self.field_model.list_group()
fields = {}
for group in field_group:
for field in group['fields']:
if field['type'] == 'input':
if custom_field.has_key(field['namespace']):
fields.update({
field['namespace']:
custom_field[field['namespace']]
})
else:
fields.update({field['namespace']: ""})
elif field['type'] == 'select':
if custom_field.has_key(field['namespace']):
fields.update({
field['namespace']:
custom_field[field['namespace']]
})
else:
fields.update({field['namespace']: []})
elif field['type'] == 'file':
if custom_field.has_key(field['namespace']):
file_ids = []
for file_id in custom_field[field['namespace']]:
file_ids.append(ObjectId(file_id))
fields.update({field['namespace']: file_ids})
else:
fields.update({field['namespace']: []})
elif field['type'] == 'date':
if custom_field.has_key(field['namespace']):
if custom_field[field['namespace']]:
custom_field[field['namespace']] = libs.str_to_utc(
custom_field[field['namespace']], "%Y-%m-%d")
fields.update({
field['namespace']:
custom_field[field['namespace']]
})
else:
fields.update({field['namespace']: ""})
elif field['type'] == 'department':
if custom_field.has_key(field['namespace']):
departments = custom_field[field['namespace']]
for department in departments:
if field['treeCheckStrictly']:
department = ObjectId(department['value'])
else:
department = ObjectId(department)
fields.update({field['namespace']: departments})
else:
fields.update({field['namespace']: []})
elif field['type'] == 'member':
if custom_field.has_key(field['namespace']):
members = custom_field[field['namespace']]
for member in members:
member = ObjectId(member)
fields.update({field['namespace']: members})
else:
fields.update({field['namespace']: []})
return self.user_model.add(fields, status, insurance, taxes, fund,
salary, salaries), code, message
def completed(self, custom_field):
""" completed profile """
current_user, code, message = self.get_current()
status = "admitted"
code = 0
message = ""
_id = str(current_user['_id'])
field_group = self.field_model.list_group()
fields = {}
for group in field_group:
for field in group['fields']:
if field['fill']:
if field['type'] == 'input':
if custom_field.has_key(field['namespace']):
fields.update({
field['namespace']:
custom_field[field['namespace']]
})
else:
fields.update({field['namespace']: ""})
elif field['type'] == 'select':
if custom_field.has_key(field['namespace']):
fields.update({
field['namespace']:
custom_field[field['namespace']]
})
else:
fields.update({field['namespace']: []})
elif field['type'] == 'file':
if custom_field.has_key(field['namespace']):
file_ids = []
for file_id in custom_field[field['namespace']]:
file_ids.append(ObjectId(file_id))
fields.update({field['namespace']: file_ids})
else:
fields.update({field['namespace']: []})
elif field['type'] == 'date':
if custom_field.has_key(field['namespace']):
if custom_field[field['namespace']]:
custom_field[
field['namespace']] = libs.str_to_utc(
custom_field[field['namespace']],
"%Y-%m-%d")
fields.update({
field['namespace']:
custom_field[field['namespace']]
})
else:
fields.update({field['namespace']: ""})
elif field['type'] == 'department':
if custom_field.has_key(field['namespace']):
departments = custom_field[field['namespace']]
for department in departments:
if field['treeCheckStrictly']:
department = ObjectId(department['value'])
else:
department = ObjectId(department)
fields.update({field['namespace']: departments})
else:
fields.update({field['namespace']: []})
elif field['type'] == 'member':
if custom_field.has_key(field['namespace']):
members = custom_field[field['namespace']]
for member in members:
member = ObjectId(member)
fields.update({field['namespace']: members})
else:
fields.update({field['namespace']: []})
return self.user_model.completed(_id, status, fields), code, message
def update(self, _id, custom_field, insurance, taxes, fund, salary,
salaries):
""" completed profile """
current_user = self.user_model.find_id(_id)
code = 0
message = ""
field_group = self.field_model.list_group()
fields = {}
for group in field_group:
for field in group['fields']:
if field['type'] == 'input':
if custom_field.has_key(field['namespace']):
fields.update({
field['namespace']:
custom_field[field['namespace']]
})
else:
fields.update({field['namespace']: ""})
elif field['type'] == 'select':
if custom_field.has_key(field['namespace']):
fields.update({
field['namespace']:
custom_field[field['namespace']]
})
else:
fields.update({field['namespace']: []})
elif field['type'] == 'file':
if custom_field.has_key(field['namespace']):
file_ids = []
for file_id in custom_field[field['namespace']]:
file_ids.append(ObjectId(file_id))
fields.update({field['namespace']: file_ids})
else:
fields.update({field['namespace']: []})
elif field['type'] == 'date':
if custom_field.has_key(field['namespace']):
if custom_field[field['namespace']]:
custom_field[field['namespace']] = libs.str_to_utc(
custom_field[field['namespace']], "%Y-%m-%d")
fields.update({
field['namespace']:
custom_field[field['namespace']]
})
else:
fields.update({field['namespace']: ""})
elif field['type'] == 'department':
if custom_field.has_key(field['namespace']):
departments = custom_field[field['namespace']]
for department in departments:
if field['treeCheckStrictly']:
department = ObjectId(department['value'])
else:
department = ObjectId(department)
fields.update({field['namespace']: departments})
else:
fields.update({field['namespace']: []})
elif field['type'] == 'member':
if custom_field.has_key(field['namespace']):
members = custom_field[field['namespace']]
for member in members:
member = ObjectId(member)
fields.update({field['namespace']: members})
else:
fields.update({field['namespace']: []})
return self.user_model.update(_id, fields, insurance, taxes, fund,
salary, salaries), code, message
def exists_custom_field(self, _id, value):
""" new member entry """
code = 0
message = ""
field_group = self.field_model.list_group()
field_name = ""
for group in field_group:
for field in group['fields']:
if str(field['_id']) == _id:
field_name = field['namespace']
break
if field_name:
break
return self.user_model.exists_custom_field(field_name,
value), code, message
def __init__(self, mongo):
self.mongo = mongo
self.dding = Dding(self.mongo)