def update_kpi(args):
try:
lock.acquire()
ret = {}
if args['data'] != None:
collection = common.get_collection('HCSLS_JobWorking')
if args['data']['kpi'].has_key('rec_id'):
check_exist = collection.find_one({
"job_w_code":
args['data']['job_w_code'],
"kpi": {
"$elemMatch": {
"rec_id": args['data']['kpi']["rec_id"]
}
}
})
if check_exist != None:
kpi = set_dict_update_kpi(args['data']['kpi'])
ret = JobWorking.update_job_kpi(args, kpi)
lock.release()
return ret
lock.release()
return dict(error="request parameter is not exist")
except Exception as ex:
lock.release()
raise (ex)
def update_factor_appraisal(args):
try:
lock.acquire()
ret = {}
if args['data'] != None:
collection = common.get_collection('HCSLS_JobWorking')
if args['data']['factor_appraisal'].has_key('rec_id'):
check_exist = collection.find_one({
"job_w_code":
args['data']['job_w_code'],
"factor_appraisal": {
"$elemMatch": {
"rec_id":
args['data']['factor_appraisal']["rec_id"]
}
}
})
if check_exist != None:
factor = set_dict_update_factor_appraisal(
args['data']['factor_appraisal'])
if (factor.has_key('factor_code')):
ret = JobWorking.update_evaluation_factor(args, factor)
else:
return dict(
error=dict(fields=['factor_code'], code="missing"))
lock.release()
return ret
lock.release()
return dict(error="request parameter is not exist")
except Exception as ex:
lock.release()
raise (ex)
def get_EmpDataByPeriodAndYear(args):
if (args['data'] != None):
ret = {}
collection = common.get_collection('TMPER_AprPeriodEmpOut').aggregate([
{
"$match": {
"$and": [{
'apr_year': args['data']['now_apr_year']
}, {
'apr_period': args['data']['now_apr_period']
}]
}
},
{
"$project": {
"apr_period": 1,
"apr_year": 1,
"employee_code": 1,
"department_code": 1,
"job_w_code": 1,
"reason": 1,
"note": 1
}
},
#{ "$sort" : SON([("apr_year",-1),("apr_period",-1)]) }
])
ret = list(collection)
return ret
def update_task(args):
try:
lock.acquire()
ret = {}
if args['data'] != None:
collection = common.get_collection('HCSLS_JobWorking')
if args['data']['task'].has_key('rec_id'):
check_exist = collection.find_one({
"job_w_code":
args['data']['job_w_code'],
"task": {
"$elemMatch": {
"rec_id": args['data']['task']["rec_id"]
}
}
})
if check_exist != None:
task = set_dict_update_task(args['data']['task'])
if (task.has_key('task_name')):
ret = JobWorking.update_job_description(args, task)
else:
return dict(
error=dict(fields=['task_name'], code="missing"))
lock.release()
return ret
lock.release()
return dict(error="request parameter is not exist")
except Exception as ex:
lock.release()
raise (ex)
def get_EmpDataByPeriodYearAndEmp(period, year, emp_code):
ret = {}
collection = common.get_collection('TMPER_AprPeriodEmpOut').aggregate([
{
"$match": {
"$and": [{
'apr_year': year
}, {
'apr_period': period
}, {
'employee_code': emp_code
}]
}
},
{
"$project": {
"_id": 1,
"apr_period": 1,
"apr_year": 1,
"employee_code": 1,
"department_code": 1,
"job_w_code": 1,
}
},
#{ "$sort" : SON([("apr_year",-1),("apr_period",-1)]) }
])
ret = list(collection)
return (lambda x: x[0] if len(x) > 0 else None)(ret)
def update_details(args):
try:
lock.acquire()
ret = {}
if args['data'] != None:
collection = common.get_collection('HCSLS_Position')
if args['data']['details'].has_key('rec_id'):
check_exist = collection.find_one(
{
"job_pos_code":args['data']['job_pos_code'],
"details":{
"$elemMatch":{
"rec_id":args['data']['details']["rec_id"]
}
}
})
if check_exist != None:
details = set_dict_detail_update_data(args['data']['details'])
ret = Position.update_details(args, details)
lock.release()
return ret
lock.release()
return dict(
error = "request parameter is not exist"
)
except Exception as ex:
lock.release()
raise(ex)
def getRootDepartment(args):
ret = {}
collection = common.get_collection('HCSSYS_Departments').aggregate([
{
"$match": {
"$and": [{
'parent_code': None
}, {
'level': 1
}]
}
},
{
"$project": {
"parent_code": 1,
"department_code": 1,
"department_name": 1,
"level_code": 1,
"level": 1,
"ordinal": 1
}
},
])
ret = list(collection)
return ret
def update_details(args):
try:
lock.acquire()
ret = {}
if args['data'] != None:
collection = common.get_collection('HCSLS_Position')
if args['data']['details'].has_key('rec_id'):
check_exist = collection.find_one(
{
"job_pos_code":args['data']['job_pos_code'],
"details":{
"$elemMatch":{
"rec_id":args['data']['details']["rec_id"]
}
}
})
if check_exist != None:
details = set_dict_detail_update_data(args['data']['details'])
ret = Position.update_details(args, details)
lock.release()
return ret
lock.release()
return dict(
error = "request parameter is not exist"
)
except Exception as ex:
lock.release()
raise(ex)
def get_genPreAperiodData(args):
if (args['data'] != None):
ret = {}
collection = common.get_collection('TMPER_AprPeriodRank').aggregate([
{
"$match": {
"$and": [{
'apr_year': int(args['data']['apr_year'])
}, {
'apr_period': int(args['data']['apr_period'])
}]
}
},
{
"$project": {
"apr_period": 1,
"apr_year": 1,
"department_code": 1,
"rank_level": 1,
"note": 1
}
},
# { "$sort" : SON([("apr_year",-1),("apr_period",-1)]) }
])
ret = list(collection)
return ret
def get_aprAprRank_by_departCode(args):
ret = {}
collection = common.get_collection('TMPER_AprPeriodRank').aggregate([
{
"$match": {
"$and": [{
'apr_period': args['apr_period']
}, {
'apr_year': args['apr_year']
}, {
'department_code':
args['departments']['department_code'][0]
}]
}
},
{
"$project": {
"_id": 1,
"apr_period": 1,
"apr_year": 1,
"department_code": 1,
"rank_level": 1,
"note": 1
}
},
])
ret = list(collection)
return (lambda x: x[0] if len(x) > 0 else None)(ret)
def get_all_department_by_year_month(args):
ret = {}
collection = common.get_collection('TMPER_AprPeriodRank').aggregate([
{
"$match": {
"$and": [{
'apr_period': args['apr_period']
}, {
'apr_year': args['apr_year']
}]
}
},
{
"$project": {
"_id": 1,
"apr_period": 1,
"apr_year": 1,
"department_code": 1,
"rank_level": 1,
"note": 1
}
},
])
ret = list(collection)
return ret
def get_list(args):
try:
items = common.get_collection('LMSLS_ExResultType').aggregate([
{
"$limit": 10000
},
{
"$group":
{
"_id": 1,
"value_list": {"$push": {"result_type1": '$result_type1'}}
}
},
{
"$unwind": {"path": '$value_list', "includeArrayIndex": 'value'
}
},
{
"$project": {
"caption": '$value_list.result_type1',
"value": 1
}
}
])
return (list(items))
except Exception as ex:
raise(ex)
def get_list_with_select_node(args):
searchText = args['data'].get('search', '')
pageSize = args['data'].get('pageSize', 0)
pageIndex = args['data'].get('pageIndex', 20)
sort = args['data'].get('sort', 20)
pageIndex = (lambda pIndex: pIndex if pIndex != None else 0)(pageIndex)
pageSize = (lambda pSize: pSize if pSize != None else 20)(pageSize)
collection = common.get_collection('LMSLS_MaterialFolder')
where = args['data'].get('where')
arrayData = []
match = {}
if(where['folder_id'] != None or searchText != None):
match = {
"$match": {
}
}
if(where['folder_id'] != None):
match["$match"]["level_code"] = where['folder_id']
if(searchText != None):
match["$match"]["folder_name"] = { "$regex": ".*" + searchText + "*" }
if(where['folder_id'] != None or searchText != None):
arrayData.append(match)
arrayData.append({
"$project": {
"folder_id":1,
"folder_name":1,
"folder_name2":1,
"parent_id":1,
"parent_code":1,
"level":1,
"level_code":1,
"ordinal":1,
"lock":1,
"note":1,
"moderator_id":1,
"approver_id":1,
"active":1,
"approve_type":1,
"created_on":1,
"created_by":1,
"modified_on":1,
"modified_by":1
}
})
if(sort != None):
arrayData.append({
"$sort": sort
})
ret=collection.aggregate(arrayData)
return dict(
items=list(ret),
page_index=pageIndex,
page_size=pageSize,
total_items=list(ret).__len__()
)
def insert_dept(args):
try:
find = qmongo.models.TM_EmailHR.aggregate.lookup(
qmongo.models.HCSEM_Employees, "employee_code", "employee_code",
"emp"
).project(
employee_code="employee_code",
email="switch(case(emp.email!='',emp.email),'')",
department_code="department_code"
).match(
"employee_code in @employee_code and department_code != @department_code",
employee_code=args['data']['list'],
department_code=None).get_list()
lst_emp = args['data']['list']
list_insert = [
item for item in lst_emp
if item not in [x['employee_code'] for x in find]
]
dict_insert = []
import HCSEM_Employees
for x in lst_emp:
if x in list_insert:
dict_insert.append({
"email":
HCSEM_Employees.get_employee_by_emp_code({
"data": {
"employee_code": x
}
}).get("email", ""),
"employee_code":
x,
"department_code":
args['data']['department_code'],
"modified_on":
None,
"modified_by":
None,
"created_on":
datetime.datetime.now(),
"created_by":
common.get_user_id()
})
rs = common.get_collection("TM_EmailHR").insert_many(dict_insert)
ret = {}
if rs.acknowledged == True:
ret = {
"error": None,
"inserted_ids": rs.inserted_ids,
}
else:
ret = {"error": "have error when insert"}
return ret
except Exception as ex:
raise (ex)
def get_kpi_by_kpi_code(args):
try:
collection = common.get_collection('TMLS_KPI')
ret = collection.aggregate([
{'$lookup': {
'foreignField': 'value',
'as': 'val',
'from': common.get_collection_name_with_schema('SYS_VW_ValueList'),
'localField': 'cycle_type'
}
},
{'$unwind': {
'path': '$val',
'preserveNullAndEmptyArrays': True
}
},
{'$match': {
'$and':[{
'$or' :[{ 'val.list_name':None},
{ 'val.list_name':'LCycleType'}]
},
{
'$or' :[{ 'val.language':None},
{ 'val.language': common.get_language()}]
}]
}
},
{'$lookup': {
'foreignField': 'unit_code',
'as': 'unit',
'from': common.get_collection_name_with_schema('HCSLS_Unit'),
'localField': 'unit_code'
}
},
{'$unwind': {
'path': '$unit',
'preserveNullAndEmptyArrays': True
}
},
{'$project': {
'kpi_name': '$kpi_name',
'is_apply_all': '$is_apply_all',
'kpi_desc': '$kpi_desc',
'cycle_type': { '$ifNull': [ '$val.caption', '' ] },
'kpi_code': { '$ifNull': [ '$kpi_code', '' ] },
'weight': '$weight',
'unit_code': { '$ifNull': [ '$unit.unit_name', '' ] },
'lock': '$lock',
'benchmark': { '$ifNull': [ '$benchmark', '' ] },
'score_from': { '$ifNull': [ '$score_from', '' ] },
'score_to': { '$ifNull': [ '$score_to', '' ] }
}
},
{'$match': {'lock': {'$ne': True}, 'kpi_code':{'$eq':args['data']['kpi_code']}}}])
return (lambda x: x[0] if x != None and len(x) > 0 else None)(list(ret))
except Exception as ex:
raise(ex)
def getListRank(args):
ret = {}
collection = common.get_collection('TMLS_Rank').aggregate([
{"$project": {
"rank_code": 1,
"rank_name": 1,
"ordinal": 1
}}
])
ret = list(collection)
return ret
def delete(args):
try:
lock.acquire()
ret = {}
if args['data'] != None:
ret = qmongo.models.TMLS_Competency.delete(
"com_code in {0}", [x["com_code"] for x in args['data']])
#delete level, delete action, delete factor
qmongo.models.TMLS_CompetencyLevel.delete(
"com_code in {0}", [x["com_code"] for x in args['data']])
qmongo.models.TMLS_CompetencyAction.delete(
"com_code in {0}", [x["com_code"] for x in args['data']])
qmongo.models.TMLS_CompetencyFactor.delete(
"com_code in {0}", [x["com_code"] for x in args['data']])
common.get_collection('HCSLS_JobWorking').update_many(
{
"competency": {
"$elemMatch": {
"com_code": {
"$in": [x["com_code"] for x in args['data']]
}
}
}
}, {
"$pull": {
"competency": {
"com_code": {
"$in": [x["com_code"] for x in args['data']]
}
}
}
})
lock.release()
return ret
lock.release()
return dict(error="request parameter is not exist")
except Exception as ex:
lock.release()
raise (ex)
def get_parent_code_by_departCode(args):
if (args != None):
ret = []
used = []
qr = qcollections.queryable(
common.get_collection("HCSSYS_Departments")).items
for i in args:
for x in qr:
if (i == x['department_code']):
ret.append(x['parent_code'])
break
unique = list(set(ret))
return unique
def exec_query(args):
import json
try:
tab = args['collection']
query = args['query']
col = common.get_collection(tab)
result = list(col.aggregate(json.loads(query)))
if result != None and len(result) > 0:
return result[0]['number']
return None
except Exception as ex:
logger.debug(ex)
return {"data": None, "error": ex.message}
def update_is_default(args):
try:
ret = common.get_collection('HCSLS_Unit').update_many(
{"is_default": True}, {"$set": {
"is_default": False
}})
ret = models.HCSLS_Unit().update({"is_default": True}, "_id == {0}",
ObjectId(args['data']["_id"]))
except Exception as ex:
raise (ex)
def get_permission(args):
user_role = models.auth_user_info.aggregate.project(username = 1, role_code = 1)\
.match("username == {0}", args['user'].username).get_item()
ret = common.get_collection("AD_Roles").aggregate([{
"$match": {
"role_code": user_role.get('role_code', None)
}
}, {
"$unwind": {
"path": "$permission",
"preserveNullAndEmptyArrays": False
}
}, {
"$match": {
"permission.function_id": args['data']['function_id']
}
}, {
"$project": {
"_id": 0,
"function_id": "$permission.function_id",
"read": "$permission.read",
"create": "$permission.create",
"write": "$permission.write",
"delete": "$permission.delete",
"export": "$permission.export",
"import": "$permission.import",
"copy": "$permission.copy",
"attach": "$permission.attach",
"download": "$permission.download",
"print": "$permission.print",
"action": "$permission.action"
}
}])
rs = list(ret)
return (lambda x: x[0] if len(x) > 0 else {
"function_id": args['data']['function_id'],
"read": False,
"create": False,
"write": False,
"delete": False,
"export": False,
"import": False,
"copy": False,
"attach": False,
"download": False,
"print": False,
"action": False
})(rs)
def getListRankcode(args):
ret = {}
collection = common.get_collection('TMLS_Rank').aggregate([
{"$lookup":{'from':common.get_collection_name_with_schema('TMPER_AprPeriodRank'), 'localField':'rank_code', 'foreignField':'rank_code', 'as': 'rr'}},
{"$unwind":{'path':'$rr', "preserveNullAndEmptyArrays":True}},
{"$project": {
"rank_code": 1,
"rank_name": 1,
"ordinal": 1,
"percent": { "$ifNull": ["$rr.percent", "0"] },
}}
])
ret = list(collection)
return ret
def get_dropdown_collections(args):
HCSSYS_CollectionInfo = common.get_collection("HCSSYS_CollectionInfo")
ret = HCSSYS_CollectionInfo.aggregate([{
'$group': {
'_id': {
"caption": "$table_name",
"value": "$table_name"
}
}
}, {
'$replaceRoot': {
'newRoot': "$_id"
}
}])
return list(ret)
def generate_list_approve_by_max_approve_level(args):
#số cấp duyệt đã có
count_approve_level = common.get_collection(
"LMS_SetupProcessApproveLevel").find({
"process_id":
int(args['data']['process_id'])
}).count()
if args['data'] != None:
max_approve_level = args['data']['max_approve_level']
if max_approve_level == None:
return None
else:
if count_approve_level < max_approve_level: #tăng số cấp duyệt
i = count_approve_level + 1
while (i <= max_approve_level):
print(i)
args['data']['rec_id'] = common.generate_guid()
args['data']['process_id'] = int(
args['data']['process_id'])
args['data']['approve_level'] = i
args['data']['approver_value'] = None
args['data']['email_approve_code'] = None
args['data']['email_approve_to'] = None
args['data']['email_approve_cc'] = None
args['data']['email_reject_code'] = None
args['data']['email_reject_to'] = None
args['data']['email_reject_cc'] = None
args['data']['default_approver_code'] = None
args['data']['not_receive_email'] = False
args['data'][
'created_on'] = None #str(datetime.datetime.now())
args['data'][
'created_by'] = "admin" #models.models.auth_user_info()["login_account"]
args['data']['modified_on'] = None
args['data']['modified_by'] = None
ret = qmongo.models.LMS_SetupProcessApproveLevel.insert(
args['data'])
i += 1
return ret
elif count_approve_level > max_approve_level: #giảm số cấp duyệt
ret = qmongo.models.LMS_SetupProcessApproveLevel.delete(
"approve_level > {0} and process_id == {1}",
max_approve_level, int(args['data']['process_id']))
return ret
return None
def get_EmpMultiByEmpcode(emp_code):
if (emp_code != ""):
ret = {}
collection = common.get_collection('HCSEM_Employees').aggregate([
{
"$match": {
'employee_code': emp_code
}
},
{
"$project": {
"employee_code": 1,
"department_code": 1,
"job_w_code": 1,
}
},
])
ret = list(collection)
return (lambda x: x[0] if len(x) > 0 else None)(ret)
def insert_force_dept(args):
emp_codes = args['data']['list']
find = qmongo.models.HCSEM_Employees.aggregate.project(
employee_code=1, email=1).match("employee_code in {0}",
emp_codes).get_list()
deleted = qmongo.models.TM_EmailHR.delete("employee_code in {0}",
emp_codes)
ret = None
try:
rs = common.get_collection("TM_EmailHR").insert_many([{
"employee_code":
x["employee_code"],
"email_address":
x["email"],
"note":
None,
"department_code":
args['data']['department_code'],
"modified_on":
None,
"modified_by":
None,
"created_on":
datetime.datetime.now(),
"created_by":
common.get_user_id()
} for x in find])
if rs.acknowledged == True:
ret = {
"error": None,
"inserted_ids": rs.inserted_ids,
}
else:
ret = {"error": "have error when insert"}
except Exception as ex:
ret = {"error": ex.message}
return ret
def test_sync_train():
client = common.login_with_test_user(common.client())
collection = common.get_collection(client, "Small Collection OpenNLP")
assert collection is not None
collection_id = collection["_id"]
assert collection_id is not None
classifier_id = client.get_collection_classifier(collection_id)["_id"]
assert classifier_id is not None
train_job_data = client.classifier_train(classifier_id, do_async=False)
_assert_job_response(train_job_data, True)
results = train_job_data["job_response"]
assert results is not None and isinstance(results, dict)
assert "average_metrics" in results and isinstance(
results["average_metrics"], dict)
assert "updated_objects" in results and isinstance(
results["updated_objects"], dict)
assert "fit" in results and isinstance(results["fit"], dict)
assert "model_filename" in results and isinstance(
results["model_filename"], str)
def remove_job_working_kpi_by_kpi_code(args):
try:
ret = common.get_collection('HCSLS_JobWorking').update_many({
"kpi":{
"$elemMatch":{
"kpi_code":args['data']['kpi_code']
}
}
},
{
'$pull':{"kpi" :{ "kpi_code": args['data']['kpi_code']}}
}
)
#if ret.raw_result['updatedExisting'] == True:
ret.raw_result.update(error=None)
return ret.raw_result
#else:
# ret.raw_result.update(error="update error")
# return ret.raw_result
except Exception as ex:
raise(ex)
def insert(args):
try:
lock.acquire()
ret = {}
if args['data'] != None:
if args['data'].has_key('_id') or args['data'].has_key('job_pos_code'):
collection = common.get_collection('HCSLS_Position')
check_exist = collection.find_one({"job_pos_code":args['data']['job_pos_code']})
if check_exist == None:
data = set_dict_insert_data(args)
ret = qmongo.models.HCSLS_Position.insert(data)
lock.release()
return ret
else:
update(args)
lock.release()
return dict(
error = "request parameter is not exist"
)
except Exception as ex:
lock.release()
raise(ex)
def insert(args):
try:
lock.acquire()
ret = {}
if args['data'] != None:
if args['data'].has_key('_id') or args['data'].has_key('job_pos_code'):
collection = common.get_collection('HCSLS_Position')
check_exist = collection.find_one({"job_pos_code":args['data']['job_pos_code']})
if check_exist == None:
data = set_dict_insert_data(args)
ret = models.HCSLS_Position().insert(data)
lock.release()
return ret
else:
update(args)
lock.release()
return dict(
error = "request parameter is not exist"
)
except Exception as ex:
lock.release()
raise(ex)
def delete_factor_appraisal(args):
try:
lock.acquire()
ret = {}
rs = {"deleted": 0, "error": None}
err = None
if args['data']['factor_code'] != None:
collection = common.get_collection('HCSLS_JobWorking')
try:
for x in args['data']['job_w_code']:
ret = collection.update({
"job_w_code": str(x).format(),
}, {
"$pull": {
"factor_appraisal": {
"factor_code": args['data']['factor_code']
}
}
}, True)
if ret['updatedExisting'] and ret['nModified'] > 0:
rs['deleted'] += ret['nModified']
lock.release()
return rs
except Exception as ex:
err = ex
lock.release()
return dict(error=(lambda x: err.message
if x != None else None)(err),
data=ret)
lock.release()
return dict(error="request parameter 'factor_code' is not exist")
except Exception as ex:
lock.release()
raise (ex)
def delete_performance_standard(args):
try:
lock.acquire()
ret = {}
error_message = None
if args['data'] != None:
if args['data'].has_key('job_w_code'):
if args['data'].has_key('rec_id'):
collection = common.get_collection('HCSLS_JobWorking')
ret = collection.update(
{"job_w_code": args['data']['job_w_code']}, {
'$pull': {
"kpi": {
"rec_id": {
'$in': args['data']['rec_id']
}
}
}
}, True)
lock.release()
return ret
else:
error_message = "parameter 'rec_id' is not exist"
else:
error_message = "parameter 'job_w_code' is not exist"
lock.release()
return dict(error=error_message)
else:
error_message = "request parameter is not exist"
lock.release()
return dict(error=error_message)
except Exception as ex:
lock.release()
raise (ex)
def update_details(args):
try:
lock.acquire()
ret = {}
if args['data'] != None:
collection = common.get_collection('TMLS_Rank')
if args['data']['details'].has_key('rec_id'):
check_exist = collection.find_one(
{
"rank_code":args['data']['rank_code'],
"setup_change_object":{
"$elemMatch":{
"change_object":args['data']['details']["change_object"],
"object_code":args['data']['details']["object_code"]
}
}
})
if check_exist == None:
details = service.set_dict_detail_update_data(args['data']['details'], args['data']['rank_code'])
ret = TMLS_Rank.update_details(args, details)
else:
ret = {
"error" : "duplicate",
"item" : check_exist
}
lock.release()
return ret
lock.release()
return dict(
error = "request parameter is not exist"
)
except Exception as ex:
lock.release()
raise(ex)
def get_quads_collection(db):
return get_collection(db, MongoDBConfig.COLLECTION_QUADS)
def get_nodes_collection(db):
return get_collection(db, MongoDBConfig.COLLECTION_NODES)
