def POST(self, **kwargs):
try:
data = cherrypy.request.json
error_message = verify_in_data(data=data,
attrs=['name', 'description'])
if error_message:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'team')
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client.teams
result = db.teams.find_one({"name": data['name']})
if not result:
try:
db.teams.insert(
dict(name=data['name'],
description=data['description']))
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR %
'new_team')
raise Exception
else:
error_message = format(EXCEPTION_DATA_ALREADY_EXISTS % 'team')
raise Exception
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def GET(self, project_name, **kwargs):
try:
error_message=None
if project_name:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
result = db.overview.find_one()
if result:
response = dict()
response['background'] = result['background']
response['purpose_scope'] = result['purpose_scope']
response['overview'] = result['overview']
else:
response = dict()
response['background'] = ''
response['purpose_scope'] = ''
response['overview'] = ''
return build_response(json=response,token=None)
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'project_name')
raise Exception
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def DELETE(self):
try:
error_message = None
data = cherrypy.request.json
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
diagram_connections = db.diagram_connections
diagram_connections.update(
{
'viewpoint': data['viewpoint'],
'diagram_name': data['diagram_name'],
'diagram_version': data['diagram_version'],
'target_element_html_id': data['target_element_html_id']
}, {"$set"
'deleted': True}, {'upsert': False})
diagram_connections.update(
{
'viewpoint': data['viewpoint'],
'diagram_name': data['diagram_name'],
'diagram_version': data['diagram_version'],
'source_element_html_id': data['source_element_html_id']
}, {"$set"
'deleted': True}, {'upsert': False})
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def GET(self, project_name, **kwargs):
try:
error_message=None
if project_name:
result = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
result = db.utility_tree.find_one()
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'utility_tree')
raise Exception
if result:
return build_response(json=result['utility_tree'],token=None)
else:
return build_response(token=None)
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'utility_tree')
raise Exception
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, **kwargs):
try:
error_message = None
stakeholders_types = list()
stakeholders_types.append((('Investors'), ('Investors')))
stakeholders_types.append(
(('Customers_and_users'), ('Customers and users')))
stakeholders_types.append((('Employees'), ('Employees')))
stakeholders_types.append(
(('Regulatory_authorities_and_governments'),
('Regulatory authorities and governments')))
stakeholders_types.append(
(('Partners_and_alliances'), ('Partners and alliances')))
stakeholders_types.append(
(('External_entities'), ('External entities')))
stakeholders_types.append((('Architects'), ('Architects')))
stakeholders_types.append(
(('Developers_and_testers'), ('Developers and testers')))
stakeholders_types.append(
(('Supply_chain_associates'), ('Supply chain associates')))
return build_response(json=stakeholders_types, token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def POST(self, **kwargs):
try:
data = cherrypy.request.json
error_message = verify_in_data(
data=data,
attrs=['stakeholder_type', 'project_name', 'concerns', 'name'])
if error_message:
error_message = format(EXCEPTION_DATA_NOT_EXISTS %
'stakeholder')
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
result = db.stakeholders.find_one({"name": data['name']})
if not result:
try:
db.stakeholders.insert(
dict(name=data['name'],
stakeholder_type=data['stakeholder_type'].replace(
"_", " "),
concerns=data['concerns']))
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR %
'new_stakeholder')
raise Exception
else:
error_message = format(EXCEPTION_DATA_ALREADY_EXISTS %
'stakeholder')
raise Exception
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def GET(self, viewpoint, diagram_name, diagram_version):
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
try:
error_message = None
results = list(
db.diagram_elements.find({
'viewpoint': viewpoint,
'diagram_name': diagram_name,
'diagram_version': diagram_version,
'deleted': False
}))
if results:
elements = list()
for result in results:
dicts = dict()
dicts['element_name'] = result['element_name']
dicts['element_type'] = result['element_type']
dicts['element_html_id'] = result['element_html_id']
dicts['top'] = result['top']
dicts['left'] = result['left']
elements.append(dicts)
return build_response(json=elements, token=None)
else:
return build_response(json=list(), token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def POST(self, **kwargs):
try:
data = cherrypy.request.json
error_message = verify_in_data(data=data, attrs=['background','purpose_scope','overview','project_name'])
if error_message:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'overview')
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
result = db.overview.find_one()
if not result:
try:
db.overview.insert(dict(background=data['background'],purpose_scope=data['purpose_scope'],overview=data['overview']))
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'new_overview')
raise Exception
else:
db.overview.update({"_id": result['_id']}, {"$set": dict(background=data['background'],purpose_scope=data['purpose_scope'],overview=data['overview'])})
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, **kwargs):
try:
error_message = None
result = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client.teams
results = list(db.teams.find())
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'teams')
raise Exception
if results:
teams = list()
for result in results:
dicts = dict()
dicts['name'] = result['name']
dicts['description'] = result['description']
teams.append(dicts)
return build_response(json=teams, token=None)
else:
return build_response(json=list(), token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def GET(self, project_name, **kwargs):
try:
error_message=None
result = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
results = list(db.constraints.find())
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR,'constraint')
raise Exception
if results:
constraints = list()
for result in results:
dicts=dict()
dicts['constraint']= result['constaint_type']
dicts['name']= result['name']
dicts['stakeholder']= result['stakeholder']
dicts['description']= result['description']
dicts['alternatives']= result['alternatives']
constraints.append(dicts)
return build_response(json=constraints,token=None)
else:
return build_response(json=list(),token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def POST(self):
try:
error_message=None
data = cherrypy.request.json
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
version = db.diagram_versions.count()+1
db.diagram_versions.insert({'viewpoint':data['viewpoint'], 'diagram_name':data['diagram_name'], 'diagram_version':str(version), 'date':data['date'], 'deleted':False})
if version > 1:
# Insert elements from previous version in new one
diagram_elements = MongoClient().editor.diagram_elements
diagram_connections = MongoClient().editor.diagram_connections
elems = list(diagram_elements.find({'viewpoint':data['viewpoint'], 'diagram_name':data['diagram_name'], 'diagram_version':ver, 'deleted':False}))
cons = list(diagram_connections.find({'viewpoint':data['viewpoint'], 'diagram_name':data['diagram_name'], 'diagram_version':ver, 'deleted':False}))
for elem in elems:
elem['diagram_version'] = version
diagram_elements.insert(elem)
for conn in cons:
conn['diagram_version'] = version
diagram_connections.insert(conn)
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def PUT(self,**kwargs):
try:
error_message=None
data = cherrypy.request.json
error_message = verify_in_data(data=data, attrs=['source','stimulus','artifact','enviroment','response','response_measure','quality_scenario_name','quality_atribute','quality_atribute_node','project_name'])
if error_message:
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
result = db.quality_requirements.find_one(dict(quality_atribute=data['quality_atribute'],quality_atribute_node=data['quality_atribute_node']))
if result:
for quality_scenario in result['quality_scenarios']:
if quality_scenario['name'] == data['quality_scenario_name']:
quality_scenario['name'] = data['quality_scenario_name']
quality_scenario['source'] = data['source']
quality_scenario['stimulus'] = data['stimulus']
quality_scenario['artifact'] = data['artifact']
quality_scenario['enviroment'] = data['enviroment']
quality_scenario['response'] = data['response']
quality_scenario['response_measure'] = data['response_measure']
db.quality_requirements.update({"_id": result['_id']}, {"$set": dict(quality_scenarios=result['quality_scenarios'])})
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'quality_scenario')
raise Exception
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, name=None, project_name=None, **kwargs):
try:
error_message = None
if name and project_name:
result = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
result = db.business_goals.find_one(
{"name": name.replace("_", " ")})
except Exception, e:
print '\n\n\n Exception--', e, '\n\n\n'
error_message = format(EXCEPTION_PROCESSING_ERROR %
'business_goals')
return build_response(json=dict(), token=None)
#raise Exception
if result:
business_goals = dict()
business_goals['stakeholders'] = result['stakeholders']
business_goals['quality_atributes'] = result[
'quality_atributes']
business_goals['measure'] = result['measure']
business_goals['goal_description'] = result[
'goal_description']
business_goals['objective'] = result['objective']
business_goals['driver'] = result['driver']
business_goals['chart_min'] = int(result['chart_min'])
business_goals['chart_med'] = int(result['chart_med'])
business_goals['chart_max'] = int(result['chart_max'])
business_goals['range_min'] = result['range_min']
business_goals['range_max'] = result['range_max']
return build_response(json=business_goals, token=None)
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS %
'business_goals')
raise Exception
if project_name:
results = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
results = list(db.business_goals.find())
except Exception:
error_message = format(EXCEPTION_DATA_NOT_EXISTS %
'business_goals')
raise Exception
if results:
business_goals = list()
for result in results:
business_goals.append(
((result['name'].replace(" ",
"_")), (result['name'])))
return build_response(json=business_goals, token=None)
else:
return build_response(json=list(), token=None)
def PUT(self,**kwargs):
error_message = None
try:
data = cherrypy.request.json
# Do something
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def DELETE(self, id=None, **kwargs):
error_message = None
try:
if id:
# Do something
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def DELETE(self, id=None, **kwargs):
error_message=None
try:
if id:
# Do something
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def PUT(self, **kwargs):
error_message = None
try:
data = cherrypy.request.json
# Do something
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def GET(self, name=None, project_name=None, **kwargs):
try:
error_message = None
if name and project_name:
result = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
result = db.stakeholders.find_one(
{"name": name.replace("_", " ")})
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR %
'stakeholder')
raise Exception
if result:
dicts = dict()
dicts['name'] = result['name']
dicts['type'] = result['stakeholder_type']
dicts['concerns'] = result['concerns']
return build_response(json=dicts, token=None)
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS %
'stakeholder')
raise Exception
elif project_name:
result = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
results = list(db.stakeholders.find())
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR %
'stakeholder')
raise Exception
if results:
stakeholders = list()
for result in results:
dicts = dict()
dicts['name'] = result['name']
dicts['aux'] = result['name'].replace(" ", "_")
dicts['type'] = result['stakeholder_type']
dicts['concerns'] = result['concerns']
stakeholders.append(dicts)
return build_response(json=stakeholders, token=None)
else:
return build_response(json=list(), token=None)
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS %
'stakeholder')
raise Exception
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def POST(self, **kwargs):
try:
error_message=None
data = cherrypy.request.json
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
db.diagrams.insert({'viewpoint':data['viewpoint'], 'name':data['name'], 'deleted':False})
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def PUT(self):
try:
error_message=None
data = cherrypy.request.json
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
diagram_elements = db.diagram_elements
diagram_elements.update({'viewpoint':data['viewpoint'], 'diagram_name':data['diagram_name'], 'diagram_version':data['diagram_version'], 'element_name':data['element_name']}, { "$set" 'top':data['top'], 'left':data['left']},{'upsert':False})
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, **kwargs):
try:
error_message = None
types = list()
types.append((('technology'), ('Technology')))
types.append((('business'), ('Business')))
return build_response(json=types, token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def GET(self, **kwargs):
try:
error_message=None
types = list()
types.append((('technology'), ('Technology')))
types.append((('business'), ('Business')))
return build_response(json=types,token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def POST(self):
try:
error_message=None
data = cherrypy.request.json
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
diagram_connections = db.diagram_connections
diagram_connections.insert({'viewpoint':data['viewpoint'], 'diagram_name':data['diagram_name'], 'diagram_version':data['diagram_version'], 'source_element_html_id':data['source_element_html_id'], 'target_element_html_id':data['target_element_html_id'], 'deleted':False})
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def DELETE(self, delete_type=None, qa_name=None ,qa_node_name=None, project_name=None, **kwargs):
error_message=None
try:
if delete_type and project_name:
if delete_type == 'qa_node':
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
result = db.utility_tree.find_one()
if result and qa_name and qa_node_name:
try:
for quality_atribute in result['utility_tree']:
if quality_atribute['name'] == qa_name:
for node in quality_atribute['nodes']:
if node['node'] == qa_node_name:
quality_atribute['nodes'].remove(node)
db.quality_requirements.remove({"quality_atribute_node": qa_node_name})
db.utility_tree.update({"_id": result['_id']}, {"$set": dict(utility_tree=result['utility_tree'])})
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'update_utility_tree')
raise Exception
return build_response(token=None)
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'utility_tree')
raise Exception
elif delete_type == 'qa_name':
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
result = db.utility_tree.find_one()
if result and qa_name:
try:
for quality_atribute in result['utility_tree']:
if quality_atribute['name'] == qa_name:
result['utility_tree'].remove(quality_atribute)
db.quality_requirements.remove({"quality_atribute": qa_name})
db.utility_tree.update({"_id": result['_id']}, {"$set": dict(utility_tree=result['utility_tree'])})
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'update_utility_tree')
raise Exception
return build_response(token=None)
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'utility_tree')
raise Exception
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'utility_tree')
raise Exception
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, name=None, project_name=None, **kwargs):
try:
error_message=None
if name and project_name:
result = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
result = db.business_goals.find_one({"name": name.replace("_", " ")})
except Exception,e:
print '\n\n\n Exception--',e,'\n\n\n'
error_message = format(EXCEPTION_PROCESSING_ERROR % 'business_goals')
return build_response(json=dict(),token=None)
#raise Exception
if result:
business_goals = dict()
business_goals['stakeholders']=result['stakeholders']
business_goals['quality_atributes']=result['quality_atributes']
business_goals['measure']=result['measure']
business_goals['goal_description']=result['goal_description']
business_goals['objective']=result['objective']
business_goals['driver']=result['driver']
business_goals['chart_min']=int(result['chart_min'])
business_goals['chart_med']=int(result['chart_med'])
business_goals['chart_max']=int(result['chart_max'])
business_goals['range_min']=result['range_min']
business_goals['range_max']=result['range_max']
return build_response(json=business_goals,token=None)
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'business_goals')
raise Exception
if project_name:
results = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
results = list(db.business_goals.find())
except Exception:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'business_goals')
raise Exception
if results:
business_goals = list()
for result in results:
business_goals.append(((result['name'].replace(" ", "_")), (result['name'])))
return build_response(json=business_goals,token=None)
else:
return build_response(json=list(),token=None)
def GET(self, name=None, project_name=None, **kwargs):
try:
error_message=None
if name and project_name:
result = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
result = db.stakeholders.find_one({"name": name.replace ("_", " ")})
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'stakeholder')
raise Exception
if result:
dicts = dict()
dicts['name']=result['name']
dicts['type']= result['stakeholder_type']
dicts['concerns'] = result['concerns']
return build_response(json=dicts,token=None)
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'stakeholder')
raise Exception
elif project_name:
result = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
results = list(db.stakeholders.find())
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'stakeholder')
raise Exception
if results:
stakeholders = list()
for result in results:
dicts = dict()
dicts['name']= result['name']
dicts['aux']= result['name'].replace (" ", "_")
dicts['type']= result['stakeholder_type']
dicts['concerns']= result['concerns']
stakeholders.append(dicts)
return build_response(json=stakeholders,token=None)
else:
return build_response(json=list(),token=None)
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'stakeholder')
raise Exception
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, **kwargs):
try:
error_message=None
measures_types = list()
measures_types.append((('Measure_1'), ('Measure 1')))
measures_types.append((('Measure_2'), ('Measure 2')))
measures_types.append((('Measure_3'), ('Measure 3')))
measures_types.append((('Measure_4'), ('Measure 4')))
return build_response(json=measures_types,token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, **kwargs):
try:
error_message = None
measures_types = list()
measures_types.append((('Measure_1'), ('Measure 1')))
measures_types.append((('Measure_2'), ('Measure 2')))
measures_types.append((('Measure_3'), ('Measure 3')))
measures_types.append((('Measure_4'), ('Measure 4')))
return build_response(json=measures_types, token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def PUT(self, **kwargs):
try:
error_message = None
data = cherrypy.request.json
error_message = verify_in_data(
data=data,
attrs=[
'source', 'stimulus', 'artifact', 'enviroment', 'response',
'response_measure', 'quality_scenario_name',
'quality_atribute', 'quality_atribute_node', 'project_name'
])
if error_message:
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
result = db.quality_requirements.find_one(
dict(quality_atribute=data['quality_atribute'],
quality_atribute_node=data['quality_atribute_node']))
if result:
for quality_scenario in result['quality_scenarios']:
if quality_scenario['name'] == data[
'quality_scenario_name']:
quality_scenario['name'] = data[
'quality_scenario_name']
quality_scenario['source'] = data['source']
quality_scenario['stimulus'] = data['stimulus']
quality_scenario['artifact'] = data['artifact']
quality_scenario['enviroment'] = data['enviroment']
quality_scenario['response'] = data['response']
quality_scenario['response_measure'] = data[
'response_measure']
db.quality_requirements.update({"_id": result['_id']}, {
"$set":
dict(quality_scenarios=result['quality_scenarios'])
})
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS %
'quality_scenario')
raise Exception
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def PUT(self, **kwargs):
try:
data = cherrypy.request.json
error_message = verify_in_data(
data=data,
attrs=[
'name', 'goal_description', 'objective', 'driver',
'stakeholders', 'quality_atributes', 'measure',
'project_name', 'chart_min', 'chart_med', 'chart_max',
'range_min', 'range_max'
])
if error_message:
error_message = format(EXCEPTION_DATA_NOT_EXISTS,
'business_goal')
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
result = db.business_goals.find_one({"name": data['name']})
if result:
try:
db.business_goals.update({"_id": result['_id']}, {
"$set":
dict(name=data['name'],
goal_description=data['goal_description'],
objective=data['objective'],
driver=data['driver'],
stakeholders=data['stakeholders'],
quality_atributes=data['quality_atributes'],
measure=data['measure'].replace("_", " "),
chart_min=data['chart_min'],
chart_med=data['chart_med'],
chart_max=data['chart_max'],
range_min=data['range_min'],
range_max=data['range_max'])
})
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR %
'update_business_goal')
raise Exception
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS %
'business_goal')
raise Exception
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def GET(self, name=None, project_name=None, **kwargs):
try:
error_message=None
if name and project_name:
result = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
result = db.operational_scenarios.find_one({"name": name.replace ("_", " ")})
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'operational_scenarios')
raise Exception
if result:
operational_scenario = dict()
operational_scenario['stakeholder']=result['stakeholder']
operational_scenario['stakeholder_description']=result['stakeholder_description']
operational_scenario['context']=result['context']
operational_scenario['context_description']=result['context_description']
operational_scenario['inputs']=result['inputs']
operational_scenario['outputs']=result['outputs']
operational_scenario['functionality']=result['functionality']
operational_scenario['functionality_description']=result['functionality_description']
return build_response(json=operational_scenario,token=None)
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'operational_scenarios')
raise Exception
if project_name:
results = None
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
results = list(db.operational_scenarios.find())
except Exception:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'operational_scenarios')
raise Exception
if results:
operational_scenarios = list()
for result in results:
operational_scenarios.append(((result['name'].replace(" ", "_")), (result['name'])))
return build_response(json=operational_scenarios,token=None)
else:
return build_response(json=list(),token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def POST(self, **kwargs):
try:
error_message = None
data = cherrypy.request.json
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
db.diagrams.insert({
'viewpoint': data['viewpoint'],
'name': data['name'],
'deleted': False
})
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def GET(self, **kwargs):
try:
error_message=None
quality_atributes_types = list()
quality_atributes_types.append((('Performance'), ('Performance')))
quality_atributes_types.append((('Security'), ('Security')))
quality_atributes_types.append((('Interoperability'), ('Interoperability')))
quality_atributes_types.append((('Modifiability'), ('Modifiability')))
quality_atributes_types.append((('Testability'), ('Testability')))
quality_atributes_types.append((('Usability'), ('Usability')))
return build_response(json=quality_atributes_types,token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def DELETE(self, name=None, project_name=None, **kwargs):
error_message=None
try:
if name and project_name:
try:
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
db.constraints.remove({"name": name.replace ("_", " ")})
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'constraint')
raise Exception
return build_response(token=None)
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'constraint')
raise Exception
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, project_name, viewpoint, **kwargs):
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
try:
error_message=None
results = list(db.diagrams.find({'viewpoint':viewpoint,'deleted':False}))
if results:
diagrams = list()
for result in results:
dicts = dict()
dicts['name']= result['name']
dicts['viewpoint']= result['viewpoint']
diagrams.append(dicts)
return build_response(json=diagrams,token=None)
else:
return build_response(json=list(),token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, viewpoint, diagram_name, diagram_version):
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
try:
error_message=None
results = list(db.diagram_connections.find({'viewpoint':viewpoint, 'diagram_name':diagram_name, 'diagram_version':diagram_version, 'deleted':False}))
if results:
connections = list()
for result in results:
dicts = dict()
dicts['target_element_html_id']= result['target_element_html_id']
dicts['source_element_html_id']= result['source_element_html_id']
connections.append(dicts)
return build_response(json=connections,token=None)
else:
return build_response(json=list(),token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, **kwargs):
try:
error_message=None
stakeholders_types = list()
stakeholders_types.append((('Investors'), ('Investors')))
stakeholders_types.append((('Customers_and_users'), ('Customers and users')))
stakeholders_types.append((('Employees'), ('Employees')))
stakeholders_types.append((('Regulatory_authorities_and_governments'), ('Regulatory authorities and governments')))
stakeholders_types.append((('Partners_and_alliances'), ('Partners and alliances')))
stakeholders_types.append((('External_entities'), ('External entities')))
stakeholders_types.append((('Architects'), ('Architects')))
stakeholders_types.append((('Developers_and_testers'), ('Developers and testers')))
stakeholders_types.append((('Supply_chain_associates'), ('Supply chain associates')))
return build_response(json=stakeholders_types,token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def POST(self, **kwargs):
try:
data = cherrypy.request.json
error_message = verify_in_data(data=data,
attrs=['project_name', 'name'])
if error_message:
error_message = format(EXCEPTION_DATA_NOT_EXISTS,
'business_goal')
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
result = db.business_goals.find_one({"name": data['name']})
if not result:
try:
db.business_goals.insert(
dict(name=data['name'],
goal_description=str(),
objective=str(),
driver=str(),
stakeholders=list(),
quality_atributes=list(),
measure=str(),
chart_min=str('33'),
chart_med=str('33'),
chart_max=str('33'),
range_min=str('0'),
range_max=str('100')))
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR %
'new_business_goal')
raise Exception
else:
error_message = format(EXCEPTION_DATA_ALREADY_EXISTS %
'business_goal')
raise Exception
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def DELETE(self):
try:
error_message=None
data = cherrypy.request.json
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
diagram_versions = db.diagram_versions
diagram_versions.update({'viewpoint':data['viewpoint'], 'diagram_name':data['diagram_name'], 'diagram_version':data['diagram_version']}, { "$set" 'deleted':True},{'upsert':False})
return ("Diagram %s has been deleted" % data['diagram_name'])
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def PUT(self):
try:
error_message = None
data = cherrypy.request.json
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
diagram_elements = db.diagram_elements
diagram_elements.update(
{
'viewpoint': data['viewpoint'],
'diagram_name': data['diagram_name'],
'diagram_version': data['diagram_version'],
'element_name': data['element_name']
}, {
"$set"
'top': data['top'],
'left': data['left']
}, {'upsert': False})
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def POST(self, **kwargs):
try:
data = cherrypy.request.json
error_message = verify_in_data(data=data, attrs=['project_name','name'])
if error_message:
error_message = format(EXCEPTION_DATA_NOT_EXISTS,'operational_scenario')
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
result = db.operational_scenarios.find_one({"name": data['name']})
if not result:
try:
db.operational_scenarios.insert(dict(name=data['name'],inputs=list(),stakeholder=str(),context_description=str(),functionality_description=str(),functionality=str(),context=str(),outputs=list(),stakeholder_description=str()))
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'new_operational_scenario')
raise Exception
else:
error_message = format(EXCEPTION_DATA_ALREADY_EXISTS % 'operational_scenario')
raise Exception
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def POST(self, **kwargs):
try:
data = cherrypy.request.json
error_message = verify_in_data(data=data, attrs=['project_name','description','stakeholder','alternatives','constaint_type','name'])
if error_message:
error_message = format(EXCEPTION_DATA_NOT_EXISTS,'constraint')
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
result = db.constraints.find_one({"name": data['name']})
if not result:
try:
db.constraints.insert(dict(name=data['name'],stakeholder=data['stakeholder'].replace ("_", " "),description=data['description'],alternatives=data['alternatives'],constaint_type=data['constaint_type']))
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'new_constraint')
raise Exception
else:
error_message = format(EXCEPTION_DATA_ALREADY_EXISTS % 'constraint')
raise Exception
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, id=None, **kwargs):
try:
error_message = None
if id:
try:
pass
except Exception:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'user')
raise Exception
# Do something
return build_response(json={'data': 'somedata'}, token=None)
else:
some_list = list()
for user in User.objects:
print user.to_mongo().__to_dict__
# Do something
return build_response(json=some_list, token=None)
except Exception as e:
print '<<<<EXCEPTION>>>', e
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def PUT(self,**kwargs):
try:
data = cherrypy.request.json
error_message = verify_in_data(data=data, attrs=['project_name','description','stakeholder','alternatives','constaint_type','name','old_name'])
if error_message:
error_message = format(EXCEPTION_DATA_NOT_EXISTS,'constraint')
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
result = db.constraints.find_one({"name": data['old_name']})
if result:
try:
db.constraints.update({"_id": result['_id']}, {"$set": dict(name=data['name'],stakeholder=data['stakeholder'].replace ("_", " "),description=data['description'],alternatives=data['alternatives'],constaint_type=data['constaint_type'])})
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'update_constraint')
raise Exception
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'constraint')
raise Exception
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, project_name, viewpoint, **kwargs):
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[project_name]
try:
error_message = None
results = list(
db.diagrams.find({
'viewpoint': viewpoint,
'deleted': False
}))
if results:
diagrams = list()
for result in results:
dicts = dict()
dicts['name'] = result['name']
dicts['viewpoint'] = result['viewpoint']
diagrams.append(dicts)
return build_response(json=diagrams, token=None)
else:
return build_response(json=list(), token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
def POST(self, **kwargs):
try:
data = cherrypy.request.json
error_message = verify_in_data(data=data, attrs=['project_name','name'])
if error_message:
error_message = format(EXCEPTION_DATA_NOT_EXISTS,'business_goal')
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
result = db.business_goals.find_one({"name": data['name']})
if not result:
try:
db.business_goals.insert(dict(name=data['name'],goal_description=str(),objective=str(),driver=str(),stakeholders=list(),quality_atributes=list(),measure=str(),chart_min=str('33'),chart_med=str('33'),chart_max=str('33'),range_min=str('0'),range_max=str('100')))
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'new_business_goal')
raise Exception
else:
error_message = format(EXCEPTION_DATA_ALREADY_EXISTS % 'business_goal')
raise Exception
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def PUT(self,**kwargs):
try:
data = cherrypy.request.json
error_message = verify_in_data(data=data, attrs=['name','goal_description','objective','driver','stakeholders','quality_atributes','measure','project_name','chart_min','chart_med','chart_max','range_min','range_max'])
if error_message:
error_message = format(EXCEPTION_DATA_NOT_EXISTS,'business_goal')
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
result = db.business_goals.find_one({"name": data['name']})
if result:
try:
db.business_goals.update({"_id": result['_id']}, {"$set": dict(name=data['name'],goal_description=data['goal_description'],objective=data['objective'],driver=data['driver'],stakeholders=data['stakeholders'],quality_atributes=data['quality_atributes'],measure=data['measure'].replace("_", " "),chart_min=data['chart_min'],chart_med=data['chart_med'],chart_max=data['chart_max'],range_min=data['range_min'],range_max=data['range_max'])})
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'update_business_goal')
raise Exception
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'business_goal')
raise Exception
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def GET(self, id=None, **kwargs):
try:
error_message=None
if id:
try:
pass
except Exception:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'user')
raise Exception
# Do something
return build_response(json={'data':'somedata'},token=None)
else:
some_list=list()
for user in User.objects:
print user.to_mongo().__to_dict__
# Do something
return build_response(json=some_list,token=None)
except Exception as e:
print '<<<<EXCEPTION>>>',e
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def PUT(self,**kwargs):
try:
data = cherrypy.request.json
error_message = verify_in_data(data=data, attrs=['stakeholder_type','project_name','concerns','name','old_name'])
if error_message:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'stakeholder')
raise Exception
client = MongoClient(DATABASE_ADDRESS, DATABASE_PORT)
db = client[data['project_name']]
result = db.stakeholders.find_one({"name": data['old_name']})
if result:
try:
db.stakeholders.update({"_id": result['_id']}, {"$set": dict(name=data['name'],stakeholder_type=data['stakeholder_type'].replace ("_", " "),concerns=data['concerns'])})
except Exception:
error_message = format(EXCEPTION_PROCESSING_ERROR % 'new_stakeholder')
raise Exception
else:
error_message = format(EXCEPTION_DATA_NOT_EXISTS % 'stakeholder')
raise Exception
return build_response(token=None)
except Exception:
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def POST(self, **kwargs):
try:
data = cherrypy.request.json
connect('archinotes', alias='archinotes',host=DATABASE_ADDRESS, port=DATABASE_PORT)
user=User(name=data['name'])
user.switch_db('archinotes')
user.save()
error_message = None
except Exception as e:
print '<<<<<<EXCEPTION >>>>',e
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message,token=None)
def POST(self, **kwargs):
try:
data = cherrypy.request.json
connect('archinotes',
alias='archinotes',
host=DATABASE_ADDRESS,
port=DATABASE_PORT)
user = User(name=data['name'])
user.switch_db('archinotes')
user.save()
error_message = None
except Exception as e:
print '<<<<<<EXCEPTION >>>>', e
if not error_message:
error_message = EXCEPTION_PROCESSING_ERROR
return build_response(error_message=error_message, token=None)
