def mutate(self, info, peopleCode):
import utils
if utils.isAllowAccess():
result = DeletePeopleCredential()
if isPeopleCredentialByPeopleCodeExist(peopleCode, info):
# can delete
peopleCredential = selectPeopleCredentialByPeople(
peopleCode, info)
db_session.delete(peopleCredential)
db_session.commit()
result.peopleCode = peopleCode
result.status = True
result.msg = 'Delete peopleCredential\'s peopleCode \'{}\' success.'.format(
peopleCode)
else:
# can't
result.msg = 'Can\'t find this peopleCode \'{}\'.'.format(
peopleCode)
return result
def resolve_organization(self, info):
import utils
if utils.isAllowAccess():
orgs = db_session.query(OrganizationDBModel).all()
return orgs
def mutate(self, info, editData):
import utils
if utils.isAllowAccess():
toEditPeople = None
status = False
msg = ''
from mutation_people import isPeopleByPCodeExist
from db_helpers.peopleSelection import selectPeopleByPCode
from db_helpers.peopleCredentialSelection import selectPeopleCredentialByPeopleCode
if isPeopleByPCodeExist(editData.peopleCode, info):
edittingPeople = selectPeopleByPCode(editData.peopleCode, info)
edittingPeople.firstname = editData.firstname
edittingPeople.lastname = editData.lastname
edittingPeople.phone = editData.phone
edittingPeople.sexId = editData.sexId
db_session.commit()
toEditPeople = edittingPeople
status = True
msg = 'update pCode\'s {} success.'.format(editData.peopleCode)
else:
msg = 'This pCode\'s {} is not exist'.format(editData.peopleCode)
return EditPeople(
people=toEditPeople,
status=status,
msg=msg)
def mutate(self, info, peopleData):
import utils
if utils.isAllowAccess():
toAddPeople = None
ok = False
msg = 'The pCode: {} is already exist.'.format(
peopleData.peopleCode)
# import db helper
from db_helpers.peopleSelection import isPeopleByPCodeExist
if isPeopleByPCodeExist(peopleData.peopleCode, info) is not True:
toAddPeople = PeopleDBModel(peopleCode=peopleData.peopleCode,
firstname=peopleData.firstname,
lastname=peopleData.lastname,
phone=peopleData.phone,
sexId=peopleData.sexId)
db_session.add(toAddPeople)
db_session.commit()
ok = True
msg = 'Create People\s pCode: {} success.'.format(
toAddPeople.peopleCode)
return CreatePeople(people=toAddPeople, ok=ok, msg=msg)
def mutate(self, info, roleData):
import utils
if utils.isAllowAccess():
roleCode = roleData.roleCode
roleDesc = roleData.roleDesc
updatedBy = roleData.updatedBy
result = UpdateRole()
result.status = False
from mutation_role import isRoleByRoleCodeExist, selectRoleByRoleCode
if isRoleByRoleCodeExist(roleCode, info):
# can update
role = selectRoleByRoleCode(roleCode, info)
role.role_desc = roleDesc
role.updated_at = datetime.now()
role.updated_by = updatedBy
db_session.commit()
result.role = role
result.status = True
result.msg = 'Update role with roleCode \'{}\' success.'.format(
roleCode)
else:
# can't
result.msg = 'Can\' find roleCode \'{}\'.'.format(roleCode)
return result
def mutate(self, info, input):
import utils
if utils.isAllowAccess():
result = OrgCreate()
orgCode = input.orgCode
from db_helpers.orgSelection import isOrgByOrgCodeExist
if isOrgByOrgCodeExist(orgCode):
result.msg = "This orgCode '{}' is exists.".format(orgCode)
else:
from datetime import datetime
newOrg = OrganizationDBModel(orgCode=orgCode,
strCode=input.strCode,
parentOrgCode=input.parentOrgCode,
orgTypeCode=input.orgTypeCode,
orgDesc=input.orgDesc,
createdAt=datetime.now(),
createdBy=input.createdBy)
db_session.add(newOrg)
db_session.commit()
result.org = newOrg
result.status = True
result.msg = "Create Organization with orgCode '{}' success.".format(
orgCode)
return result
def mutate(self, info, updateData):
import utils
if utils.isAllowAccess():
newPosCode = updateData.posCode
newPosDesc = updateData.pos_desc
from mutation_position import selectPositionByPosCode, isPositionByPosCodeExist
result = UpdatePosition()
result.status = False
if isPositionByPosCodeExist(newPosCode, info):
# can update
pos = selectPositionByPosCode(newPosCode, info)
pos.posCode = newPosCode
pos.pos_desc = newPosDesc
db_session.commit()
result.status = True
result.position = pos
result.msg = 'Update Postion by posCode \'{}\' success.'.format(
newPosCode)
else:
# can't
result.msg = 'Can\'t find this posCode \'{}\'.'.format(
newPosCode)
return result
def mutate(self, info, posCode):
import utils
if utils.isAllowAccess():
result = DeletePosition()
result.status = False
from mutation_position import selectPositionByPosCode, isPositionByPosCodeExist
if isPositionByPosCodeExist(posCode, info):
# can delete
pos = selectPositionByPosCode(posCode, info)
db_session.delete(pos)
db_session.commit()
result.posCode = posCode
result.status = True
result.msg = 'Delete position\'s posCode \'{}\' success.'.format(
posCode)
else:
# can't
result.msg = 'Can\'t find this posCode \'{}\''.format(posCode)
return result
def mutate(self, info, input):
import utils
if utils.isAllowAccess():
strCode = input.strCode
result = UpdateStructure()
from db_helpers.structureSelection import isStructureByStrCodeExist, selectStructureByStrCode
if isStructureByStrCodeExist(strCode):
# let update
from datetime import datetime
toUpdateStr = selectStructureByStrCode(strCode)
toUpdateStr.strDesc = input.strDesc
toUpdateStr.updatedBy = input.updatedBy
toUpdateStr.updatedAt = datetime.now()
db_session.commit()
result.structure = toUpdateStr
result.status = True
result.msg = "Update structure with strCode '{}' success.".format(
strCode)
else:
result.msg = "Can't find strCode '{}'.".format(strCode)
return result
def mutate(self, info, roleData):
import utils
if utils.isAllowAccess():
roleCode = roleData.roleCode
roleDesc = roleData.roleDesc
result = CreateRole()
result.status = False
from mutation_role import isRoleByRoleCodeExist
if isRoleByRoleCodeExist(roleCode, info) is False:
# can create
newRole = RoleDBModel()
newRole.roleCode = roleCode
newRole.role_desc = roleDesc
db_session.add(newRole)
db_session.commit()
result.role = newRole
result.status = True
result.msg = 'Create role with roleCode \'{}\' success.'.format(
roleCode)
else:
# can't
result.msg = 'This roleCode \'{}\' is exist.'.format(roleCode)
return result
def mutate(self, info, credentialData):
import utils
if utils.isAllowAccess():
from hashlib import sha256
from settings.app import ENCODE_SECRET
from db_helpers.peopleSelection import isPeopleByPCodeExist
from db_helpers.peopleCredentialSelection import selectPeopleCredentialByPeople, isPeopleCredentialByPeopleCodeExist
peopleCode = credentialData.peopleCode
email = credentialData.email
password = credentialData.password.encode('utf-8')
hashedPassword = sha256(password).hexdigest()
result = CreatePeopleCredential()
result.status = False
if isPeopleByPCodeExist(peopleCode, info):
# found peopleCode
# mean user is already add this people.
# ask in PeopleCredentialTable that peopleCode is exist or not.
if isPeopleCredentialByPeopleCodeExist(peopleCode,
info) is False:
# peopleCode is not exist in PeopleCreatial table
# let's insert
newCredential = PeopleCredentialDBModel(
peopleCode=peopleCode,
email=email,
password=hashedPassword)
db_session.add(newCredential)
db_session.commit()
result.peopleCredential = newCredential
result.status = True
result.msg = 'Create people\'s credential success.'
else:
result.msg = 'This peopleCode \'{}\' is already exist.'.format(
peopleCode)
else:
# this peopleCode is not exist. [need to add create new people first]
result.msg = 'Can\'t find this peopleCode \'' + peopleCode + '\'.'
result.msg += ' You need to create new People first.'
return result
def mutate(self, info, strCode):
import utils
if utils.isAllowAccess():
result = DeleteStructure()
from db_helpers.structureSelection import deleteStructureByStrCode
if deleteStructureByStrCode(strCode):
result.status = True
result.msg = "Delete Structure with strCode '{}' success.".format(
strCode)
else:
result.msg = "Can't find strCode '{}'.".format(strCode)
return result
def resolve_getPositionByPosCode(self, info, posCode):
import utils
if utils.isAllowAccess():
result = GetPositionByPosCodeReturnFields()
result.status = False
pos = selectPositionByPosCode(posCode, info)
if pos is not None:
result.position = pos
result.status = True
else:
result.msg = 'Can\'t find this posCode \'{}\'.'.format(posCode)
return result
def resolve_roleByRoleCode(self, info, roleCode):
import utils
if utils.isAllowAccess():
result = RoleByRoleCodeResult()
from db_helpers.roleSelection import selectRoleByRoleCode
role = selectRoleByRoleCode(roleCode, info)
if role is not None:
result.role = role
result.status = True
else:
result.msg = 'This PosCode: \'{}\' is not exist.'.format(roleCode)
return result
def resolve_structureBy(self, info, strCode):
import utils
if utils.isAllowAccess():
result = GetStructureByStrCodeResult()
from db_helpers.structureSelection import (
isStructureByStrCodeExist,
selectStructureByStrCode)
if isStructureByStrCodeExist(strCode):
structure = selectStructureByStrCode(strCode)
result.structure = structure
result.status = True
else:
result.msg = "Can't find this strCode '{}'.".format(strCode)
return result
def mutate(self, info, updateData):
import utils
if utils.isAllowAccess():
peopleCode = updateData.peopleCode
email = updateData.email
password = updateData.password.encode('utf-8')
updatedBy = updateData.updatedBy
result = UpdatePeopleCredential()
if isPeopleCredentialByPeopleCodeExist(
peopleCode, info) and isPeopleByPCodeExist(
peopleCode, info):
# let's update
from datetime import datetime
now = datetime.now()
import hashlib
hashedPassword = hashlib.sha256(password).hexdigest()
toUpdatePeopleCredential = selectPeopleCredentialByPeople(
peopleCode, info)
toUpdatePeopleCredential.email = email
toUpdatePeopleCredential.password = hashedPassword
toUpdatePeopleCredential.updated_at = now
toUpdatePeopleCredential.updated_by = updatedBy
db_session.commit()
result.peopleCredential = toUpdatePeopleCredential
result.status = True
result.msg = 'Update peopleCredential with peopleCode \'{}\' success.'.format(
peopleCode)
else:
# can't update
result.msg = 'Can\'t find this peopleCode \'{}\'.'.format(
peopleCode)
return result
def mutate(self, info, roleCode):
import utils
if utils.isAllowAccess():
result = DeleteRole()
from db_helpers.roleSelection import selectRoleByRoleCode, isRoleByRoleCodeExist
if isRoleByRoleCodeExist(roleCode, info):
toDeleteRole = selectRoleByRoleCode(roleCode, info)
db_session.delete(toDeleteRole)
db_session.commit()
result.status = True
result.msg = "Delete Role with roleCode '{roleCode}' success."
else:
result.msg = "Can't find roleCode {roleCode}."
return result
def mutate(self, info, peopleCode):
import utils
if utils.isAllowAccess():
msg = ''
status = False
from mutation_people import isPeopleByPCodeExist, selectPeopleByPCode
if isPeopleByPCodeExist(peopleCode, info):
delettingPeople = selectPeopleByPCode(peopleCode, info)
db_session.delete(delettingPeople)
db_session.commit()
status = True
msg = 'delete pCode\'s {} success.'.format(peopleCode)
else:
msg = 'This pCode\'s {} is not exist'.format(peopleCode)
return DeletePeople(peopleCode=peopleCode, msg=msg, status=status)
def mutate(self, info, orgCode):
import utils
if utils.isAllowAccess():
result = OrgDelete()
from db_models.orgSelection import isOrgByOrgCodeExist, selectOrgByOrgCode
if isOrgByOrgCodeExist(orgCode):
toDeleteOrg = selectOrgByOrgCode(orgCode)
db_session.delete(toDeleteOrg)
db_session.commit()
result.status = True
result.msg = "Delete organziation by orgCode '{}' success.".format(
orgCode)
else:
result.msg = "Org by this orgCode '{}' is not exist.".format(
orgCode)
return result
def mutate(self, info, input):
import utils
if utils.isAllowAccess():
result = CreatePeoplePosRole()
from db_helpers.peopleSelection import isPeopleByPCodeExist
from db_helpers.positionSelection import isPositionByPosCodeExist
from db_helpers.roleSelection import isRoleByRoleCodeExist
from db_helpers.peoplePosRoleSelection import isPeoplePosRoleExist
if isPeoplePosRoleExist(input, info) is False:
# check peopleCode, positionCode, roleCode if they are exist or not ?
if isPeopleByPCodeExist(input.peopleCode, info) and isPositionByPosCodeExist(input.posCode, info) and isRoleByRoleCodeExist(input.roleCode, info):
# let's save
newPeoplePosRole = PeoplePosRoleDBModel()
newPeoplePosRole.peopleCode = input.peopleCode
newPeoplePosRole.posCode = input.posCode
newPeoplePosRole.roleCode = input.roleCode
db_session.add(newPeoplePosRole)
db_session.commit()
result.peoplePosRole = newPeoplePosRole
result.status = True
result.msg = "Create peopleCode: {}, posCode: {}, roleCode: {} success.".format(input.peopleCode, input.posCode, input.roleCode)
else:
result.msg = "Some if theme is not exist in their table."
else:
result.msg = "These peopleCode: {}, posCode: {}, roleCode: {} are exist.".format(
input.peopleCode,
input.posCode,
input.roleCode)
return result
def mutate(self, info, positionData):
import utils
if utils.isAllowAccess():
from mutation_position import isPositionByPosCodeExist
newPos = None
status = False
msg = 'This posCode \'{}\' is exist.'.format(positionData.posCode)
if isPositionByPosCodeExist(positionData.posCode, info) is False:
newPos = PositionDBModel()
newPos.posCode = positionData.posCode
newPos.pos_desc = positionData.pos_desc
db_session.add(newPos)
db_session.commit()
status = True
msg = 'Create position\'s posCode {} success.'.format(
positionData.posCode)
return CreatePosition(position=newPos, status=status, msg=msg)
def resolve_peopleByPeopleCode(self, info, peopleCode):
if utils.isAllowAccess():
query = PeopleSchemaModel.get_query(info)
people = query.filter(
PeopleDBModel.peopleCode == peopleCode).first()
result = GetPeopleByPcodeReturnField()
if people is not None:
# get position in people
from db_helpers.peopleSelection import selectPositionInPeopleByPeopleCode
posInPeople = selectPositionInPeopleByPeopleCode(
people.peopleCode, info)
result.status = True
result.people = people
# add position into people
result.people.position = posInPeople
else:
result.msg = 'This p_code is not exist.'
return result
def resolve_structure(self, info):
import utils
if utils.isAllowAccess():
return selectAllStructure()
def resolve_role(self, info):
import utils
if utils.isAllowAccess():
query = RoleSchemaModel.get_query(info)
return query.all()
def resolve_position(self, info):
import utils
if utils.isAllowAccess():
query = PositionSchemaModel.get_query(info)
return query.all()
