def putValueChain(data, uuid):
row = getValueChain(uuid)
r = valueChainAreaCrud.getValueChainArea(data['valueChainArea'])
changes = compareDict(row=row, data=data)['modified']
if r != row.valueChainArea:
changes['valueChainArea'] = (row.valueChainArea.uuid, r.uuid)
row.title = data['title']
row.desc = data['desc']
row.modified = datetime.now()
row.modifiedBy = session['user_uuid']
row.valueChainArea_uuid = r.uuid
row.valueChainArea = r
try:
db.session.commit()
putLog(table='valueChain', uuid=unicode(uuid), changes=changes)
return {'success': 'Value Chain updated'}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='valueChain')
return {'error': 'Value Chain already exist'}
else:
errorLog(unicode(E), table='valueChain')
return {'error': unicode(E)}
def putCausingFactor(data, uuid):
row = getCausingFactor(uuid)
c = causingFactorTypeCrud.getCausingFactorType(data['causingFactorType'])
changes = compareDict(row=row, data=data)['modified']
if c != row.causingFactorType:
changes['causingFactorType'] = (row.causingFactorType.uuid, c.uuid)
row.title = data['title']
row.desc = data['desc']
row.modified = datetime.now()
row.modifiedBy = session['user_uuid']
row.causingFactorType_uuid = c.uuid
row.causingFactorType = c
try:
db.session.commit()
putLog(table='causingFactor', uuid=unicode(uuid), changes=changes)
return {'success': 'Causing Factor updated'}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='causingFactor')
return {'error': 'Causing Factor already exist'}
else:
errorLog(unicode(E), table='causingFactor')
return {'error': unicode(E)}
def putRegion(data, uuid):
row = getRegion(uuid)
changes = compareDict(row=row, data=data)['modified']
row.title = data['title']
row.abbr = data['abbr']
row.modified = datetime.now()
row.modifiedBy = session['user_uuid']
if data['subRegions']:
for sr in data['subRegions']:
row.subRegions.append(subRegionCrud.getSubRegion(unicode(sr)))
else:
row.subRegions[:] = []
if data['subRegions'] != row.subRegions[:]:
changes['subRegions'] = (row.subRegions.uuid, r.uuid)
try:
db.session.commit()
putLog(table='region', uuid=unicode(uuid), changes=changes)
return {'success': 'Region updated'}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='region')
return {'error': 'Region already exist'}
else:
errorLog(unicode(E), table='region')
return {'error': unicode(E)}
def putSubRegion(data, uuid):
row = getSubRegion(uuid)
reg = regionCrud.getRegion(data['region'])
changes = compareDict(row=row, data=data)['modified']
if reg != row.region:
changes['region'] = (row.region.uuid,r.uuid)
row.title = data['title']
row.abbr = data['abbr']
row.modified = datetime.now()
row.modifiedBy = session['user_uuid']
row.region = reg
row.region_uuid = reg.uuid
try:
db.session.commit()
putLog(table='subRegion', uuid=unicode(uuid), changes=changes)
return {'success': 'Sub Region updated'}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='subRegion')
return {'error': 'Sub Region already exist'}
else:
errorLog(unicode(E), table='subRegion')
return {'error': unicode(E)}
def putRating(data, uuid):
row = getRating(uuid)
i = impactCrud.getImpact(data['impact'])
p = probabilityCrud.getProbability(data['probability'])
changes = compareDict(row=row, data=data)['modified']
if i != row.impact:
changes['impact'] = (row.impact.uuid,i.uuid)
if p != row.probability:
changes['probability'] = (row.probability.uuid,p.uuid)
row.value = data['value']
row.desc = data['desc']
row.modified = datetime.now()
row.modifiedBy = session['user_uuid']
row.impact_uuid = i.uuid
row.impact = i
row.probability_uuid = p.uuid
row.probability = p
try:
db.session.commit()
putLog(table='rating', uuid=unicode(uuid), changes=changes)
return {'success': 'Rating updated'}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='rating')
return {'error': 'Rating already exist'}
else:
errorLog(unicode(E), table='rating')
return {'error': unicode(E)}
def putZone(data, uuid):
row = getZone(uuid)
c = countryCrud.getCountry(data['country'])
changes = compareDict(row=row, data=data)['modified']
if c != row.country:
changes['country'] = (row.country.uuid, r.uuid)
row.title = data['title']
row.abbr = data['abbr']
row.modified = datetime.now()
row.modifiedBy = session['user_uuid']
row.country = c
row.country_uuid = c.uuid
try:
db.session.commit()
putLog(table='zone', uuid=unicode(uuid), changes=changes)
return {'success': 'Zone updated'}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='zone')
return {'error': 'Zone already exist'}
else:
errorLog(unicode(E), table='zone')
return {'error': unicode(E)}
def putTreatment(data, uuid):
row = getTreatment(uuid)
t = treatmentTypeCrud.getTreatmentType(data['treatmentType'])
r = riskResponseCrud.getRiskResponse(data['riskResponse'])
# Discover changes to row
changes = compareDict(row=row, data=data)['modified']
if t != row.treatmentType:
changes['treatmentType'] = (row.treatmentType.uuid, t.uuid)
if r != row.riskResponse:
changes['riskResponse'] = (row.riskResponse.uuid, r.uuid)
# Assign changes to row
row.title = data['title']
row.desc = data['desc']
row.modified = datetime.now()
row.modifiedBy = session['user_uuid']
row.riskResponse_uuid = r.uuid
row.riskResponse = r
row.treatmentType_uuid = t.uuid
row.treatmentType = t
try:
db.session.commit()
putLog(table='treatment', uuid=unicode(uuid), changes=changes)
return {'success': 'Treatment updated'}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='treatment')
return {'error': 'Treatment already exist'}
else:
errorLog(unicode(E), table='treatment')
return {'error': unicode(E)}
def putGroup(data, uuid):
try:
dataDict = {
'name': data['title'],
'desc': data['desc'],
'users': data['users']
}
req = authAPI(endpoint='group/' + unicode(uuid),
method='put',
dataDict=dataDict,
token=session['token'])
if 'error' in req:
return {'error': req['error']}
else:
grp = getGroup(uuid)
changes = compareDict(row=grp, data=data)['modified']
try:
currentUsers = [r.uuid for r in grp.users]
except:
currentUsers = []
try:
newUsers = [
user.query.filter_by(uuid=unicode(r)).first().uuid
for r in data['users']
]
except:
newUsers = []
if currentUsers != newUsers:
changes['users'] = (currentUsers, newUsers)
grp.title = data['title']
grp.desc = data['desc']
grp.users = [
user.query.filter_by(uuid=unicode(r)).first()
for r in data['users']
]
grp.modified = datetime.now()
grp.modifiedBy = session['user_uuid']
try:
db.session.commit()
putLog(table='group', uuid=unicode(uuid), changes=changes)
return {'success': 'Group has been modified'}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='group')
return {'error': 'Group already exist'}
else:
errorLog(unicode(E), table='group')
return {'error': unicode(E)}
except Exception as E:
return {'error': unicode(E)}
def putUser(data, uuid):
usr = getUser(uuid)
changes = compareDict(row=row, data=data)['modified']
try:
currentGroups = [r.uuid for r in usr.groups]
except:
currentGroups = []
try:
newGroups = [group.query.filter_by(uuid=unicode(r)).first().uuid for r in data['groups']]
except:
newGroups = []
if currentGroups != newGroups:
changes['groups'] = (currentGroups,newGroups)
usr.groups = [group.query.filter_by(uuid=unicode(r)).first() for r in data['groups']]
usr.initials = data['initials']
usr.name = data['name']
usr.email = data['email']
usr.phone = data['phone']
usr.role = data['role']
usr.modified = datetime.now()
usr.modifiedBy = session['user_uuid']
dataDict = {'name': data['name'],
'email': data['email'],
'phone': data['phone'],
'groups': data['groups'],
'roles': [data['role']]}
try:
db.session.add(usr)
db.session.commit()
req = authAPI(endpoint='user/'+unicode(uuid), method='put', dataDict=dataDict, token=session['token'])
if not 'error' in req:
putLog(table='user', uuid=unicode(uuid), changes=changes)
return {'success':'User has been modified'}
else:
errorLog(req['error'], table='user')
return {'error':req['error']}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='user')
return {'error': 'User already exist'}
else:
errorLog(unicode(E), table='user')
return {'error': unicode(E)}
def putRisk(data, uuid):
row = getRisk(uuid)
i = impactCrud.getImpact(data['impact'])
p = probabilityCrud.getProbability(data['probability'])
ra = riskAreaCrud.getRiskArea(data['riskArea'])
rt = riskTypeCrud.getRiskType(data['riskType'])
ro = userCrud.getUser(data['owner'])
changes = compareDict(row=row, data=data)['modified']
if i != row.impact:
changes['impact'] = (row.impact.uuid,i.uuid)
if p != row.probability:
changes['probability'] = (row.probability.uuid,p.uuid)
if ra != row.riskArea:
changes['riskArea'] = (row.riskArea.uuid,p.uuid)
if rt != row.riskType:
changes['riskType'] = (row.riskType.uuid,p.uuid)
if ro != row.riskOwner:
changes['riskOwner'] = (row.riskOwner.uuid,p.uuid)
row.title = data['title']
row.desc = data['desc']
row.modified = datetime.now()
row.modifiedBy = session['user_uuid']
row.impact_uuid = i.uuid
row.impact = i
row.probability_uuid = p.uuid
row.probability = p
row.riskArea_uuid = ra.uuid
row.riskArea = ra
row.riskType_uuid = rt.uuid
row.riskType = rt
row.owner = data['owner']
row.riskOwner = ro
try:
db.session.commit()
putLog(table='risk', uuid=unicode(uuid), changes=changes)
return {'success': 'Risk updated'}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='risk')
return {'error': 'Risk already exist'}
else:
errorLog(unicode(E), table='risk')
return {'error': unicode(E)}
def putStatus(data, uuid):
row = getStatus(uuid)
changes = compareDict(row=row, data=data)['modified']
row.title = data['title']
row.modified = datetime.now()
row.modifiedBy = session['user_uuid']
try:
db.session.commit()
putLog(table='status', uuid=unicode(uuid), changes=changes)
return {'success': 'Status updated'}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='status')
return {'error': 'Status already exist'}
else:
errorLog(unicode(E), table='status')
return {'error': unicode(E)}
def putDeliveryPoint(data, uuid):
row = getDeliveryPoint(uuid)
changes = compareDict(row=row, data=data)['modified']
row.title = data['title']
row.desc = data['desc']
row.modified = datetime.now()
row.modifiedBy = session['user_uuid']
try:
db.session.commit()
putLog(table='deliveryPoint', uuid=unicode(uuid), changes=changes)
return {'success': 'Delivery Point updated'}
except Exception as E:
if 'unique constraint' in unicode(E):
return {'error': 'Delivery Point already exist'}
else:
return {'error': unicode(E)}
def putProbability(data, uuid):
row = getProbability(uuid)
changes = compareDict(row=row, data=data)['modified']
row.title = data['title']
row.desc = data['desc']
row.value = data['value']
row.modified = datetime.now()
row.modifiedBy = session['user_uuid']
try:
db.session.commit()
putLog(table='probability', uuid=unicode(uuid), changes=changes)
return {'success': 'Probability updated'}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='probability')
return {'error': 'Probability already exist'}
else:
errorLog(unicode(E), table='probability')
return {'error': unicode(E)}
def putImpact(data, uuid):
row = getImpact(uuid)
changes = compareDict(row=row, data=data)['modified']
row.title = data['title']
row.cost = data['cost']
row.schedule = data['schedule']
row.requirements = data['requirements']
row.legal = data['legal']
row.other = data['other']
row.value = data['value']
row.modified = datetime.now()
row.modifiedBy = session['user_uuid']
try:
db.session.commit()
putLog(table='impact', uuid=unicode(uuid), changes=changes)
return {'success': 'Impact updated'}
except Exception as E:
if 'unique constraint' in unicode(E):
errorLog('Unique constraint', table='impact')
return {'error': 'Impact already exist'}
else:
errorLog(unicode(E), table='impact')
return {'error': unicode(E)}
