def draftdata(self):
draft_data = None
draft_repo = repos.DomainRepo("Draftdata")
search_f = {"name": self.name}
draft_data_lst = draft_repo.list_dict(**search_f)
if draft_data_lst and len(draft_data_lst) > 0:
draft_data = draft_data_lst[0]
return draft_data
def wfactions(self):
wfaction_repo = repos.DomainRepo('Wfaction')
searh_filter = {
"associated_doctype": {
"name": self.associated_doctype_name
}
}
result = wfaction_repo.list_domain_obj(**searh_filter)
return result
def wfmaster_delete_by_name(objname, unique_identifier):
try:
repo = repos.DomainRepo(objname)
filter = {"name": unique_identifier}
result = repo.delete(**filter) #convert dict as name=value with **
except (rexc.InvalidWorkflowObject, rexc.InvalidInputDataDict,
rexc.InvalidKeysInData) as errObj:
result = errObj.ret_val
except Exception as err:
result = {'status': "unknown", 'msg': str(err)}
return json.dumps(result)
def wfmaster_update(objname):
try:
repo = repos.DomainRepo(objname)
result = repo.update_from_dict(request.json.get('update_data_dict'),
**request.json.get('search_filter'))
except (rexc.InvalidWorkflowObject, rexc.InvalidInputDataDict,
rexc.InvalidKeysInData) as errObj:
result = errObj.ret_val
except Exception as err:
result = {'status': "unknown", 'msg': str(err)}
return json.dumps(result)
def wfmaster_add(objname, wfc):
#print('''print wfc.....''', wfc.__dict__)
try:
repo = repos.DomainRepo(objname)
result = repo.add_form_lod(request.json)
except (rexc.InvalidWorkflowObject, rexc.InvalidInputDataList,
rexc.InvalidInputDataDict, rexc.InvalidKeysInData) as errObj:
result = errObj.ret_val
except Exception as err:
result = {'status': "unknown", 'msg': str(err)}
return json.dumps(result)
def wfmaster_delete(objname):
print("request.json in delete", request.json)
try:
repo = repos.DomainRepo(objname)
result = repo.delete(**
request.json) #convert dict as name=value with **
except (rexc.InvalidWorkflowObject, rexc.InvalidInputDataDict,
rexc.InvalidKeysInData) as errObj:
result = errObj.ret_val
except Exception as err:
result = {'status': "unknown", 'msg': str(err)}
return json.dumps(result)
def wfmaster_list_multiple_searchkey(objname):
'''
GET method to use for listing all or filter by a single key
POST method is used to capture the filters'''
try:
repo = repos.DomainRepo(objname)
result = repo.list_json(
**request.json) #convert dict as name=value with **
except (rexc.InvalidWorkflowObject, rexc.InvalidInputDataDict,
rexc.InvalidKeysInData) as errObj:
result = errObj.ret_val
except Exception as err:
result = {'status': "unknown", 'msg': str(err)}
return result
def from_dict(cls, data_dict):
for k,v in data_dict.items():
if k in cls.related_obj_map.keys():
related_class = cls.related_obj_map.get(k).get('mapped_object')
if not (isinstance(v, dict ) or isinstance(v, related_class)):
raise rexc.InvalidObjTypeInInputParam(k, dict)
if isinstance(v, dict ):
primary_key = cls.related_obj_map.get(k).get('primary_key')
if not primary_key in v:
raise rexc.PrimaryKeyNotPresentInSearch(primary_key, v)
relobjname = cls.related_obj_map.get(k).get('mapped_object').__name__
relobjrepo = repos.DomainRepo(relobjname)
result_list = relobjrepo.list_domain_obj(**v)
data_dict.update({k: result_list[0]})
elif isinstance(v, related_class):
data_dict.update({k: v})
return cls(**data_dict)
def _register_doctype_n_actions(self):
doctype1 = ent.Doctype("doctype1", "dk1", ['role1'])
doctype2 = ent.Doctype("doctype2", "dk2", ['role1'])
lodobj = [doctype1, doctype2]
doctype_repo = DomainRepo("Doctype")
doctype_repo.add_list_of_domain_obj(lodobj)
####DEFINING FIELDS FOR DOCTYPE2
f1_dict = {
"name": "dk1",
"associated_doctype": {
"name": "doctype2"
},
"ftype": "str",
"flength": 25,
"status_needed_edit": ["s1", "Created",
"s2"], #this should be status not role
"wfc_filter": "",
"wfc_filter_to_roles": []
}
f2_dict = {
"name": "dk2",
"associated_doctype": {
"name": "doctype2"
},
"ftype": "str",
"flength": 10,
"status_needed_edit": [""],
"wfc_filter": "",
"wfc_filter_to_roles": []
}
f3_dict = {
"name": "tsp",
"associated_doctype": {
"name": "doctype2"
},
"ftype": "str",
"flength": 10,
"status_needed_edit": [""],
"wfc_filter": "org",
"wfc_filter_to_roles": ['r1']
}
f4_dict = {
"name": "division",
"associated_doctype": {
"name": "doctype2"
},
"ftype": "str",
"flength": 10,
"status_needed_edit": [""],
"wfc_filter": "ou",
"wfc_filter_to_roles": ['r3']
}
docf_repo = repos.DomainRepo("Datadocfield")
docf_repo.add_form_lod([f1_dict, f2_dict, f3_dict, f4_dict])
wfcaction_create = {
"name": "Create",
"associated_doctype": {
"name": "doctype2"
},
#"need_prev_status": "NewBorn",
"need_current_status": ["NewBorn"],
"leads_to_status": "Created",
"permitted_to_roles": [
"r1",
],
"hide_to_roles": ["r7"],
"undo_prev_hide_for": [],
}
wfaction1_dict = {
"name": "wfaction1",
"associated_doctype": {
"name": "doctype2"
},
#"need_prev_status": "NewBorn",
"need_current_status": ["Created"],
"leads_to_status": "s1",
"permitted_to_roles": [
"r1",
],
"hide_to_roles": ["r4", "r5"],
"undo_prev_hide_for": [],
}
wfaction2_dict = {
"name": "wfaction2",
"associated_doctype": {
"name": "doctype2"
},
#"need_prev_status": "Created",
"need_current_status": ["s1"],
"leads_to_status": "s2",
"permitted_to_roles": [
"r2",
],
"hide_to_roles": ["r5", "r6"],
"undo_prev_hide_for": [
"r4",
], #r4 hold doc shold be deleted but r5 to be retained
}
wfaction3_dict = {
"name": "wfaction3",
"associated_doctype": {
"name": "doctype2"
},
#"need_prev_status": "s1",
"need_current_status": ["s2"],
"leads_to_status": "s3",
"permitted_to_roles": [
"r3",
],
"hide_to_roles": [
"r1",
],
"undo_prev_hide_for": ["r5", "r6"],
}
wfaction4_dict = {
"name": "wfaction4",
"associated_doctype": {
"name": "doctype2"
},
#"need_prev_status": "s2",
"need_current_status": ["s3"],
"leads_to_status": "s4",
"permitted_to_roles": [
"r3",
],
"hide_to_roles": [
"r5",
],
"undo_prev_hide_for": [],
}
wfactionCreate = ent.Wfaction.from_dict(wfcaction_create)
wfaction1 = ent.Wfaction.from_dict(wfaction1_dict)
wfaction2 = ent.Wfaction.from_dict(wfaction2_dict)
wfaction3 = ent.Wfaction.from_dict(wfaction3_dict)
lodobj = [wfactionCreate, wfaction1, wfaction2, wfaction3]
action_repo = DomainRepo("Wfaction")
action_repo.add_list_of_domain_obj(lodobj)
def test_repos(self):
m.dbdriver.delete(m.Holddoc)
m.dbdriver.delete(m.Wfdocaudit)
m.dbdriver.delete(m.Wfdoc)
m.dbdriver.delete(m.Wfaction)
m.dbdriver.delete(m.Wfstatus)
m.dbdriver.delete(m.Datadocfield)
m.dbdriver.delete(m.Doctype)
#####INITIALIZE A REPO FOR DOMAIN ENTITY
statrepo = repos.DomainRepo("Wfstatus")
##############ADD ENTITY
status_lod = [{"name": "Status1111"}]
msg = statrepo.add_form_lod(status_lod)
self.assertTrue(msg['message'] == "has been registered")
##################LIST OBJECTS FROM REPO
msg = statrepo.list_obj(name="Status1111")
self.assertTrue(msg[0].name == 'Status1111')
############LIST THE ENTITIES AS DICT
msg = statrepo.list_dict(name="Status1111")
self.assertTrue(msg[0]['name'] == 'Status1111')
##########UPDATE THE ENTITIES
updated_data_dict = {"name": "Status222222"}
searchf = {"name": "Status1111"}
msg = statrepo.update_from_dict(updated_data_dict, **searchf)
self.assertTrue(msg['status'] == "success")
##########DELETE
####delete on on existing document is also saying succress to be tested
msg = statrepo.delete(name='Status222222')
self.assertTrue("deleted successfully" in msg)
msg = statrepo.list_obj()
self.assertTrue(not msg)
##########Test LOD WHEN RELATION
Doctype_lod = [{
"name": "doctype1",
"primkey_in_datadoc": "dk1"
}, {
"name": "doctype2",
"primkey_in_datadoc": "dk2"
}]
doctype_repo = repos.DomainRepo("Doctype")
msg = doctype_repo.add_form_lod(Doctype_lod)
self.assertTrue(msg['message'] == "has been registered")
Wfaction_lod = [{
"name": "name1",
"associated_doctype": {
"name": "doctype1"
},
"need_current_status": [
"s1",
],
"leads_to_status": "s2",
"permitted_to_roles": [
"r1",
],
"hide_to_roles": [
"r1",
],
"undo_prev_hide_for": [
"r1",
]
}]
actionrepo = repos.DomainRepo("Wfaction")
msg = actionrepo.add_form_lod(Wfaction_lod)
self.assertTrue(msg['message'] == 'has been registered')
msg = actionrepo.list_dict()
self.assertTrue(isinstance(msg[0], dict))
self.assertTrue(msg[0]['associated_doctype_name'] == 'doctype1')
searchf = {"name": "name1"}
updated_data_dict = {
"name": "name1",
"associated_doctype": {
"name": "doctype2"
},
"need_current_status": ["s1"],
"leads_to_status": "s2",
"permitted_to_roles": [
"r1",
],
"hide_to_roles": [
"r1",
],
"undo_prev_hide_for": [
"r1",
]
}
msg = actionrepo.update_from_dict(updated_data_dict, **searchf)
self.assertTrue(msg['status'] == "success")
def _register_doctype_n_actions(self):
m.dbdriver.delete(m.Wfdoc)
m.dbdriver.delete(m.Wfaction)
m.dbdriver.delete(m.Wfstatus)
m.dbdriver.delete(m.Datadocfield)
m.dbdriver.delete(m.Doctype)
doctype1 = ent.Doctype("doctype1", "dk1")
doctype2 = ent.Doctype("doctype2", "invoiceno")
lodobj = [doctype1, doctype2]
doctype_repo = DomainRepo("Doctype")
doctype_repo.add_list_of_domain_obj(lodobj)
####DEFINING FIELDS FOR DOCTYPE2
f1_dict = {
"name": "invoiceno",
"associated_doctype": {
"name": "doctype2"
},
"ftype": "str",
"flength": 100,
"status_needed_edit": [""]
} #this should be status not role
f2_dict = {
"name": "dk2",
"associated_doctype": {
"name": "doctype2"
},
"ftype": "str",
"flength": 10,
"status_needed_edit": ["Created"]
}
docf_repo = repos.DomainRepo("Datadocfield")
docf_repo.add_form_lod([f1_dict, f2_dict])
wfcaction_create = {
"name": "Create",
"associated_doctype": {
"name": "doctype2"
},
"need_prev_status": "NewBorn",
"need_current_status": "NewBorn",
"leads_to_status": "Created",
"permitted_to_roles": [
"role1",
]
}
wfaction1_dict = {
"name": "wfaction1",
"associated_doctype": {
"name": "doctype2"
},
"need_prev_status": "",
"need_current_status": "Created",
"leads_to_status": "s1",
"permitted_to_roles": [
"r1",
]
}
wfaction2_dict = {
"name": "wfaction2",
"associated_doctype": {
"name": "doctype2"
},
"need_prev_status": "Created",
"need_current_status": "s1",
"leads_to_status": "s2",
"permitted_to_roles": [
"r2",
]
}
wfaction3_dict = {
"name": "wfaction3",
"associated_doctype": {
"name": "doctype2"
},
"need_prev_status": "s1",
"need_current_status": "s2",
"leads_to_status": "s3",
"permitted_to_roles": [
"r3",
]
}
wfactionCreate = ent.Wfaction.from_dict(wfcaction_create)
wfaction1 = ent.Wfaction.from_dict(wfaction1_dict)
wfaction2 = ent.Wfaction.from_dict(wfaction2_dict)
wfaction3 = ent.Wfaction.from_dict(wfaction3_dict)
lodobj = [wfactionCreate, wfaction1, wfaction2, wfaction3]
action_repo = DomainRepo("Wfaction")
action_repo.add_list_of_domain_obj(lodobj)
def get_wfmobj_keys(objname):
repo = repos.DomainRepo(objname)
objkeys = repo.get_wfmobj_keys()
return json.dumps(objkeys)
def test_entities(self):
m.dbdriver.delete(m.Holddoc)
m.dbdriver.delete(m.Wfdocaudit)
m.dbdriver.delete(m.Wfdoc)
m.dbdriver.delete(m.Wfaction)
m.dbdriver.delete(m.Wfstatus)
m.dbdriver.delete(m.Datadocfield)
m.dbdriver.delete(m.Doctype)
docrepo = DomainRepo("Wfdoc")
###########REGISTER DOCTYPE
doctype1 = ent.Doctype("doctype1", "dk1", ["r1"])
doctype2 = ent.Doctype("doctype2", "dk2", ["r1"])
lodobj = [doctype1, doctype2]
doctype_repo = DomainRepo("Doctype")
msg = doctype_repo.add_list_of_domain_obj(lodobj)
self.assertTrue(msg['message'] == "has been registered")
########REGISTER ACTION RULES
wfaction1_dict = {
"name": "wfaction1",
"associated_doctype": {
"name": "doctype1"
},
"need_prev_status": "s0",
"need_current_status": "s1",
"leads_to_status": "s2",
"permitted_to_roles": [
"r1",
],
"hide_to_roles": [
"r5",
]
}
wfaction2_dict = {
"name": "wfaction2",
"associated_doctype": {
"name": "doctype2"
},
"need_prev_status": "s1",
"need_current_status": "s2",
"leads_to_status": "s3",
"permitted_to_roles": [
"r2",
],
"hide_to_roles": [
"r5",
]
}
wfaction3_dict = {
"name": "wfaction3",
"associated_doctype": {
"name": "doctype2"
},
"need_prev_status": "s2",
"need_current_status": "s3",
"leads_to_status": "s4",
"permitted_to_roles": [
"r3",
],
"hide_to_roles": [
"r5",
]
}
wfaction1 = ent.Wfaction.from_dict(wfaction1_dict)
wfaction2 = ent.Wfaction.from_dict(wfaction2_dict)
wfaction3 = ent.Wfaction.from_dict(wfaction3_dict)
lodobj = [wfaction1, wfaction2, wfaction3]
action_repo = DomainRepo("Wfaction")
msg = action_repo.add_list_of_domain_obj(lodobj)
self.assertTrue(msg['message'] == "has been registered")
############RETRIEVE ACTION1 FROM REPO
doctype_list_sobj = doctype_repo.list_obj()
self.assertTrue(isinstance(doctype_list_sobj[0], m.Doctype))
doctype_list_dobj = doctype_repo.list_domain_obj()
self.assertTrue(isinstance(doctype_list_dobj[0], ent.Doctype))
action_list_dict = action_repo.list_dict()
self.assertTrue(
isinstance(action_list_dict[0]['associated_doctype'], dict))
action_list_sobj = action_repo.list_obj()
self.assertTrue(isinstance(action_list_sobj[0], m.Wfaction))
action_list_dobj = action_repo.list_domain_obj()
self.assertTrue(isinstance(action_list_dobj[0], ent.Wfaction))
seearchf = {"associated_doctype": {"name": "doctype2"}}
action_list_filtered_by_doctype = action_repo.list_domain_obj(
**seearchf)
self.assertTrue(action_list_filtered_by_doctype[0].associated_doctype.
name == 'doctype2')
self.assertTrue(action_list_filtered_by_doctype[1].associated_doctype.
name == 'doctype2')
####UPDATE RELATTIONSHIP FIELD ACTION1 DOCTYPE FROM 1 TO 2
wfaction1_dict.update({"associated_doctype": {"name": "doctype2"}})
searchf = {"name": "wfaction1"}
msg = action_repo.update_from_dict(wfaction1_dict, **searchf)
self.assertTrue(msg['status'] == "success")
action_list_filtered_by_doctype = action_repo.list_domain_obj(
**seearchf)
self.assertTrue(len(action_list_filtered_by_doctype) == 3)
####DEFINING FIELDS FOR DOCTYPE2
f1_dict = {
"name": "field1",
"associated_doctype": {
"name": "doctype2"
},
"ftype": "str",
"flength": 2,
"status_needed_edit": ["s3"]
}
f2_dict = {
"name": "field2",
"associated_doctype": {
"name": "doctype2"
},
"ftype": "int",
"flength": 2,
"status_needed_edit": [""]
}
docf_repo = repos.DomainRepo("Datadocfield")
msg = docf_repo.add_form_lod([f1_dict, f2_dict])
self.assertTrue(msg['status'] == "success")
datadocfields_repo = repos.DomainRepo("Datadocfield")
searh_filter = {"associated_doctype": {"name": "doctype2"}}
result = datadocfields_repo.list_domain_obj(**searh_filter)
fnames = [item.name for item in result]
self.assertTrue("field1" in fnames)
###CHECK THE ID ATTRIBUTE FROM SQL OBJ HAS BEEN PASSED TO DOMAINOBJ
#self.assertTrue(hasattr(action_list_filtered_by_doctype[0], 'id'))
doc_data1 = {"field1": "v1", "field2": 10}
primval_datadoc = doc_data1["field1"]
wfdoc_dict1 = {
"name": primval_datadoc,
"associated_doctype": {
"name": "doctype2"
},
"prev_status": "s2",
"current_status": "s3",
"doc_data": doc_data1,
}
wfdoc_lod = [wfdoc_dict1]
wfdoc_repo = repos.DomainRepo("Wfdoc")
msg = wfdoc_repo.add_form_lod(wfdoc_lod)
#######RETRIEVE DOC USING PRIMKEY
wfdoc_list = wfdoc_repo.list_domain_obj(**{"name": "v1"})
##########SEE THE COMNNETS above IN CASE OF INPUT TYPE EXCEPTION
self.assertTrue(len(wfdoc_list[0].wfactions) == 3)
self.assertTrue((wfdoc_list[0].doc_data == doc_data1))
#####FROM DICT CREATE DOMAIN OBJ AND THEN SAVE TO REPO
doc_data1 = {"field1": "v2", "field2": 10}
primval_datadoc = doc_data1["field1"]
wfdoc_dict2 = {
"name": primval_datadoc,
"associated_doctype": {
"name": "doctype2"
},
"prev_status": "s2",
"current_status": "s3",
"doc_data": doc_data1,
}
wfdoc2 = ent.Wfdoc.from_dict(wfdoc_dict2)
###ADD THE DOMAIN OBJECT TO THE DOMAIN REPO
msg = wfdoc_repo.add_list_of_domain_obj([wfdoc2])
self.assertTrue(msg['message'] == "has been registered")
###SEE DOCTYPE2 HAVE THE DOCDATAFIELDS
doctype2Obj_list = doctype_repo.list_domain_obj(**{"name": "doctype2"})
###CREATE DOC ONCE ITS FIELDS ARE DEFINED ABOVE
doc_data3 = {"field1": "v3", "field2": 10}
wfdoc_dict3 = {
"name": 'v3',
"associated_doctype": {
"name": "doctype2"
},
"prev_status": "",
"current_status": "Created",
"doc_data": doc_data3,
}
###FAIL FOR FIELD NAME MISTACH
try:
ent.Wfdoc.from_dict(wfdoc_dict3)
except rexc.UnknownFieldNameInDataDoc as e:
self.assertTrue(e.status == "UnknownFieldNameInDataDoc")
##FAILURE FOR FIELD LENGTH LARGER THAN CONFIGURED
doc_data3 = {"field1": "v44444", "field2": 10}
wfdoc_dict3.update({"doc_data": doc_data3})
try:
ent.Wfdoc.from_dict(wfdoc_dict3)
except rexc.DataLengthViolation as e:
self.assertTrue(e.status == "DataLengthViolation")
####FAIL FOR FIELD TYPE, FIELD2 SHOULD BE INT TYPE
wfdoc_dict3.update({
"name": "v3",
"doc_data": {
"field1": "v3",
"field2": "v2"
}
})
try:
ent.Wfdoc.from_dict(wfdoc_dict3)
except rexc.DataTypeViolation as e:
self.assertTrue(e.status == "DataTypeViolation")
###########CHECK SUCCESS
wfdoc_dict3.update({
"name": "v3",
"doc_data": {
"field1": "v3",
"field2": 10
}
})
docobj = ent.Wfdoc.from_dict(wfdoc_dict3)
self.assertTrue(docobj.name == "v3")
def datadocfields(self):
datadocfields_repo = repos.DomainRepo("Datadocfield")
searh_filter = {"associated_doctype": {"name": self.name}}
result = datadocfields_repo.list_domain_obj(**searh_filter)
return result
def wfdocs(self):
wfdoc_repo = repos.DomainRepo('Wfdoc')
searh_filter = {"associated_doctype": {"name": self.name}}
result = wfdoc_repo.list_domain_obj(**searh_filter)
return result
def wfdocaudits(self):
wfdocaudit_repo = repos.DomainRepo('Wfdocaudit')
searh_filter = {"wfdoc": {"name": self.name}}
result = wfdocaudit_repo.list_domain_obj(**searh_filter)
return result
