def create(self, **kwargs):
cr, uid, context = request.cr, request.session.uid, request.context
password = request.session.password
version = release.version_info[0]
if version==9:
csrf_token = request.csrf_token()
else :
csrf_token = 'None'
if not request.session.uid:
return http.local_redirect('/saas/create')
else :
user_id = request.session.uid
partner_id = request.registry['res.users'].read(cr, uid, user_id, ['partner_id'])['partner_id'][0]
if len(kwargs):
values = {'user':partner_id,
'host_name': kwargs['domain_name'],
'server':kwargs.get('server_select', False),
}
ids = request.registry['saas.user.info'].create(cr, uid, values,context=context)
#request.registry['saas.user.info'].create_use_db(cr, uid, [ids],password,context=context)
template = request.registry('ir.model.data').get_object(cr, SUPERUSER_ID, 'saas_admin', 'registry_saas_db_email')
request.registry('email.template').send_mail(cr, SUPERUSER_ID, template.id, ids, force_send=True, raise_exception=True, context=context)
users = http.request.env['saas.user.info']
servers = http.request.env['saas.server']
values = {
'users': users.search([]),
'servers': servers.search([]),
'password':password,
'csrf_token':csrf_token
}
return http.request.render('saas_website.list', values)
def confirm_clinical(self, *args, **kw):
task_id = kw.get('task_id') # TODO: add a check if is None (?)
cr, uid, context = request.cr, request.uid, request.context
api = request.registry('nh.eobs.api')
activity_api = request.registry('nh.activity')
kw_copy = kw.copy() if kw else {}
if 'taskId' in kw_copy:
del kw_copy['taskId']
if 'frequency' in kw_copy:
kw_copy['frequency'] = int(kw_copy['frequency'])
if 'location_id' in kw_copy:
kw_copy['location_id'] = int(kw_copy['location_id'])
# TODO: add a check if method 'complete' fails(?)
api.complete(cr, uid, int(task_id), kw_copy)
triggered_ids = activity_api.search(
cr, uid, [['creator_id', '=', int(task_id)]])
triggered_tasks_read = activity_api.read(cr, uid, triggered_ids, [])
triggered_tasks = []
for trig_task in triggered_tasks_read:
access = api.check_activity_access(cr,
uid,
trig_task['id'],
context=context)
is_not_ob = 'ews' not in trig_task['data_model']
if access and is_not_ob:
triggered_tasks.append(trig_task)
response_data = {'related_tasks': triggered_tasks, 'status': 1}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Submission successful',
description='The notification was successfully submitted',
data=response_data)
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def process_ajax_form(self, *args, **kw):
observation = kw.get('observation') # TODO: add a check if is None (?)
task_id = kw.get('task_id') # TODO: add a check if is None (?)
cr, uid, context = request.cr, request.uid, request.context
api = request.registry('nh.eobs.api')
activity_api = request.registry('nh.activity')
ob_str = 'nh.clinical.patient.observation.' + observation
ob_pool = request.registry(ob_str)
converter_pool = request.registry('ir.fields.converter')
converter = converter_pool.for_model(cr,
uid,
ob_pool,
str,
context=context)
kw_copy = kw.copy() if kw else {}
data_timestamp = kw_copy.get('startTimestamp', None)
data_task_id = kw_copy.get('taskId', None)
data_device_id = kw_copy.get('device_id', None)
if data_timestamp is not None:
del kw_copy['startTimestamp']
if data_task_id is not None:
del kw_copy['taskId']
if task_id is not None:
del kw_copy['task_id']
if observation is not None:
del kw_copy['observation']
if data_device_id is not None:
del kw_copy['device_id']
for key, value in kw_copy.items():
if not value:
del kw_copy[key]
converted_data = converter(kw_copy, _logger.debug)
if data_timestamp is not None:
converted_data['date_started'] = \
datetime.fromtimestamp(int(data_timestamp)).strftime(DTF)
if data_device_id is not None:
converted_data['device_id'] = data_device_id
api.complete(cr, uid, int(task_id), converted_data, context)
activity = activity_api.browse(cr, uid, int(task_id))
obs = activity.data_ref
description = self.get_submission_message(obs)
response_data = obs.get_submission_response_data()
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Successfully Submitted{0} {1}'.format(
' Partial' if obs.is_partial else '',
ob_pool.get_description()),
description=description,
data=response_data)
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def get_patient(self, patient_id, *args, **kw):
"""
Renders the :class:`patient<base.nh_clinical_patient>` view.
:returns: patient response object
:rtype: :class:`http.Response<openerp.http.Response>`
"""
try:
patient_id = int(patient_id)
except ValueError:
return utils.redirect(URLS['patient_list'], 303)
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
patient_list = api_pool.get_patients(cr,
uid, [patient_id],
context=context)
if not patient_list:
return utils.redirect(URLS['patient_list'], 303)
elif len(patient_list) > 0:
patient = patient_list[0]
obs = api_pool.get_active_observations(cr,
uid,
patient_id,
context=context)
for index, ob in enumerate(obs):
if ob['type'] == 'ews':
obs.insert(0, obs.pop(index))
if ob['type'] == 'gcs':
obs.insert(1, obs.pop(index))
if ob['type'] == 'pain':
obs.insert(2, obs.pop(index))
follow_activities = api_pool.get_assigned_activities(
cr,
uid,
activity_type='nh.clinical.patient.follow',
context=context)
obs_data_vis_list = api_pool.get_data_visualisation_resources(
cr, uid, context=context)
user_group_ids = request.registry('res.users').read(
cr, uid, uid, ['groups_id'])
user_groups = request.registry('res.groups').read(
cr, uid, user_group_ids.get('groups_id'), ['display_name'])
user_groups = [rec.get('display_name') for rec in user_groups]
return request.render('nh_eobs_mobile.patient',
qcontext={
'patient': patient,
'urls': URLS,
'section': 'patient',
'obs_list': obs,
'notification_count': len(follow_activities),
'username': request.session['login'],
'data_vis_list': obs_data_vis_list,
'user_groups': user_groups
})
def get_patient(self, patient_id, *args, **kw):
"""
Renders the :class:`patient<base.nh_clinical_patient>` view.
:returns: patient response object
:rtype: :class:`http.Response<openerp.http.Response>`
"""
try:
patient_id = int(patient_id)
except ValueError:
return utils.redirect(URLS['patient_list'], 303)
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
patient_list = api_pool.get_patients(
cr, uid, [patient_id], context=context)
if not patient_list:
return utils.redirect(URLS['patient_list'], 303)
elif len(patient_list) > 0:
patient = patient_list[0]
obs = api_pool.get_active_observations(
cr, uid, patient_id, context=context)
for index, ob in enumerate(obs):
if ob['type'] == 'ews':
obs.insert(0, obs.pop(index))
if ob['type'] == 'gcs':
obs.insert(1, obs.pop(index))
if ob['type'] == 'pain':
obs.insert(2, obs.pop(index))
follow_activities = api_pool.get_assigned_activities(
cr, uid,
activity_type='nh.clinical.patient.follow',
context=context)
obs_data_vis_list = api_pool.get_data_visualisation_resources(
cr, uid, context=context)
user_group_ids = request.registry('res.users').read(
cr, uid, uid, ['groups_id'])
user_groups = request.registry('res.groups').read(
cr, uid, user_group_ids.get('groups_id'), ['display_name']
)
user_groups = [rec.get('display_name') for rec in user_groups]
return request.render(
'nh_eobs_mobile.patient',
qcontext={
'patient': patient,
'urls': URLS,
'section': 'patient',
'obs_list': obs,
'notification_count': len(follow_activities),
'username': request.session['login'],
'data_vis_list': obs_data_vis_list,
'user_groups': user_groups
}
)
def process_ajax_form(self, *args, **kw):
observation = kw.get('observation') # TODO: add a check if is None (?)
task_id = kw.get('task_id') # TODO: add a check if is None (?)
cr, uid, context = request.cr, request.uid, request.context
api = request.registry('nh.eobs.api')
activity_api = request.registry('nh.activity')
ob_str = 'nh.clinical.patient.observation.'+observation
ob_pool = request.registry(ob_str)
converter_pool = request.registry('ir.fields.converter')
converter = converter_pool.for_model(cr, uid, ob_pool, str,
context=context)
kw_copy = kw.copy() if kw else {}
data_timestamp = kw_copy.get('startTimestamp', None)
data_task_id = kw_copy.get('taskId', None)
data_device_id = kw_copy.get('device_id', None)
if data_timestamp is not None:
del kw_copy['startTimestamp']
if data_task_id is not None:
del kw_copy['taskId']
if task_id is not None:
del kw_copy['task_id']
if observation is not None:
del kw_copy['observation']
if data_device_id is not None:
del kw_copy['device_id']
for key, value in kw_copy.items():
if not value:
del kw_copy[key]
converted_data = converter(kw_copy, _logger.debug)
if data_timestamp is not None:
converted_data['date_started'] = \
datetime.fromtimestamp(int(data_timestamp)).strftime(DTF)
if data_device_id is not None:
converted_data['device_id'] = data_device_id
api.complete(cr, uid, int(task_id), converted_data, context)
activity = activity_api.browse(cr, uid, int(task_id))
obs = activity.data_ref
description = self.get_submission_message(obs)
response_data = obs.get_submission_response_data()
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Successfully Submitted{0} {1}'.format(
' Partial' if obs.is_partial else '',
ob_pool.get_description(append_observation=True)),
description=description,
data=response_data)
return request.make_response(
response_json, headers=ResponseJSON.HEADER_CONTENT_TYPE)
def group_user_detail_query(self, **kw):
res = utils.init_response_data()
res["data"] = []
try:
group_id = int(kw.get('group_id', 0))
if not group_id:
res["code"] = status.Status.PARMAS_ERROR
return res
response = Rong.rongyun_group_user_query(group_id=group_id)
if response.has_key("data"):
user_data = response["data"]["users"]
for user in user_data:
user_id = user["id"]
res_users = request.registry("res.users")
user_obj = res_users.search_read(
request.cr, request.uid, [["user_id", "=", user_id]])
if len(user_obj):
user_obj = user_obj[0]
del user_obj["password"]
del user_obj["image_medium"]
del user_obj["image"]
del user_obj["image_small"]
res["data"].append(user_obj)
else:
continue
else:
res["code"] = status.Status.DHuiRongyunServerError
return res
except Exception, e:
res["code"] = status.Status.ERROR
res["error_info"] = str(e)
return res
def group_user_detail_query(self,**kw):
res = utils.init_response_data()
res["data"] = []
try:
group_id = int(kw.get('group_id',0))
if not group_id :
res["code"] = status.Status.PARMAS_ERROR
return res
response = Rong.rongyun_group_user_query(group_id=group_id)
if response.has_key("data"):
user_data = response["data"]["users"]
for user in user_data:
user_id = user["id"]
res_users = request.registry("res.users")
user_obj = res_users.search_read(request.cr,request.uid,[["user_id","=",user_id]])
if len(user_obj) :
user_obj = user_obj[0]
del user_obj["password"]
del user_obj["image_medium"]
del user_obj["image"]
del user_obj["image_small"]
res["data"].append(user_obj)
else :
continue
else :
res["code"] = status.Status.DHuiRongyunServerError
return res
except Exception, e:
res["code"] = status.Status.ERROR
res["error_info"] = str(e)
return res
def get_patient_barcode(self, *args, **kw):
# TODO: add a check if is None (?)
hospital_number = kw.get('hospital_number')
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
try:
patient_info = api_pool.get_patient_info(cr,
uid,
hospital_number,
context=context)
if len(patient_info) > 0:
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title=patient_info[0]['full_name'],
description='Information on {0}'.format(
patient_info[0]['full_name']),
data=patient_info[0])
else:
response_data = {'error': 'Patient not found.'}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_ERROR,
title='Patient not found',
description='Unable to get patient with ID provided',
data=response_data)
except osv.except_osv:
response_data = {'error': 'Patient not found.'}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_ERROR,
title='Patient not found',
description='Unable to get patient with ID provided',
data=response_data)
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def get_patient_obs(self, *args, **kw):
patient_id = kw.get('patient_id') # TODO: add a check if is None (?)
obs_type = kw.get('obs_type')
cr, uid = request.cr, request.uid
api_pool = request.registry('nh.eobs.api')
patient_list = api_pool.get_patients(cr, uid, [int(patient_id)])
if len(patient_list) > 0:
patient = patient_list[0]
observations = api_pool.get_activities_for_patient(
cr, uid, patient_id=int(patient_id), activity_type=obs_type)
observations.reverse()
response_data = {'obs': observations, 'obsType': obs_type}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='{0}'.format(patient['full_name']),
description='Observations for {0}'.format(
patient['full_name']),
data=response_data)
else:
response_data = {'error': 'Data not found.'}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_ERROR,
title='Data not found',
description='Unable to find data with ID and ob name provided',
data=response_data)
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def get_patient_info(self, *args, **kw):
patient_id = kw.get('patient_id') # TODO: add a check if is None (?)
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
patient_info = api_pool.get_patients(cr, uid,
[int(patient_id)],
context=context)
if len(patient_info) > 0:
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title=patient_info[0]['full_name'],
description='Information on {0}'.format(
patient_info[0]['full_name']
),
data=patient_info[0]
)
return request.make_response(
response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE
)
else:
response_data = {'error': 'Patient not found.'}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_ERROR,
title='Patient not found',
description='Unable to get patient with ID provided',
data=response_data
)
return request.make_response(
response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE
)
def get_task_form(self, cr, uid, task, patient, request, context=None):
"""
Get the form for a task
:param task: task object
:return: tuple of form and form inputs
"""
api_reg = request.registry('nh.eobs.api')
form_desc, form = self.process_form_fields(
api_reg.get_form_description(
cr, uid,
patient.get('id'),
task.get('data_model'),
context=context
)
)
form['action'] = \
URLS['task_form_action'] + '{0}'.format(task.get('id'))
form['type'] = task['data_model']
form['task-id'] = task.get('id')
form['patient-id'] = \
int(patient['id']) if patient and patient.get('id') else False
form['source'] = "task"
form['start'] = datetime.now().strftime('%s')
return form, form_desc
def user_group(self, **kw):
res = utils.init_response_data()
res["data"] = []
try:
user_id = kw.get("user_id", None)
if not user_id:
res["code"] = status.Status.PARMAS_ERROR
return res
res_users = request.registry("res.users")
user = res_users.search_read(request.cr, request.uid,
[["user_id", "=", user_id]])
if not len(user):
user = user[0]
res["code"] = status.Status.NOT_EXIST
return res
else:
user = user[0]
request.cr.execute(
"select task_id from project_task_rel where uid=%s" %
(user["id"]))
row_list = request.cr.fetchall()
project_task = request.registry("project.task")
task_id_list = []
for row in row_list:
task_id = row[0]
task_id_list.append(task_id)
task_list = project_task.read(request.cr, request.uid,
task_id_list)
for task in task_list:
res["data"].append(
dict(
id=task["id"],
create_uid=task["create_uid"],
create_date=task["create_date"],
user_id=task["user_id"],
parent=task["project_id"],
description=task["description"],
name=task["name"],
group_type=task["group_type"],
members=task["members"],
))
except Exception, e:
res["code"] = status.Status.ERROR
res["error_info"] = str(e)
return res
def populate_values(self):
values = []
cr, context = request.cr, request.context
vehicle_ids = request.registry['fleet.vehicle'].search(cr, SUPERUSER_ID,[])
driver_ids = request.registry('res.partner').search(cr,SUPERUSER_ID,[('is_driver','=',True)])
driver_info = request.registry('res.partner').read(cr,SUPERUSER_ID,driver_ids,['name','operator'])
# sorting drivers based on operators
operator_driver = {}
for i in driver_info:
if i.get('operator',False):
if i.get('operator',False)[0] in operator_driver.keys():
operator_driver[i['operator'][0]].append({
'id':i['id'],
'name':i['name']
})
else:
operator_driver.update({
i.get('operator',False)[0]:[{
'id':i['id'],
'name':i['name']
}]
})
for vehicle in request.registry('fleet.vehicle').browse(cr,SUPERUSER_ID,vehicle_ids,context):
if vehicle.operator and vehicle.operator.id in operator_driver.keys():
# looking for drivers for the operator in the driver_info
values.append(
{
'name':vehicle.name,
'id':vehicle.id,
'current_driver':vehicle.driver_id.id,
'driver_ids':operator_driver[vehicle.operator.id]
}
)
else:
values.append(
{
'name':vehicle.name,
'id':vehicle.id,
'current_driver':vehicle.driver_id.id,
'driver_ids':driver_info
}
)
return values
def user_group(self,**kw):
res = utils.init_response_data()
res["data"] = []
try:
user_id = kw.get("user_id",None)
if not user_id :
res["code"] = status.Status.PARMAS_ERROR
return res
res_users = request.registry("res.users")
user = res_users.search_read(request.cr,request.uid,[["user_id","=",user_id]])
if not len(user) :
user = user[0]
res["code"] = status.Status.NOT_EXIST
return res
else :
user = user[0]
request.cr.execute("select task_id from project_task_rel where uid=%s"%(user["id"]))
row_list = request.cr.fetchall()
project_task = request.registry("project.task")
task_id_list = []
for row in row_list:
task_id = row[0]
task_id_list.append(task_id)
task_list = project_task.read(request.cr,request.uid,task_id_list)
for task in task_list:
res["data"].append(dict(
id = task["id"],
create_uid = task["create_uid"],
create_date = task["create_date"],
user_id = task["user_id"],
parent = task["project_id"],
description = task["description"],
name = task["name"],
group_type = task["group_type"],
members =task["members"],
))
except Exception,e:
res["code"] = status.Status.ERROR
res["error_info"] = str(e)
return res
def process_form(self, task_id, *args, **kw):
cr, uid, context = request.cr, request.uid, request.context
activity_api = request.registry('nh.activity')
kw_copy = kw.copy()
del kw_copy['taskId']
kw_copy['date_started'] = datetime.fromtimestamp(
int(kw_copy['startTimestamp'])).strftime(DTF)
del kw_copy['startTimestamp']
activity_api.submit(cr, uid, int(task_id), kw_copy, context)
activity_api.complete(cr, uid, int(task_id), context)
return utils.redirect(URLS['task_list'])
def purchase_order_line_confirm(self, line_id, **data):
cr, uid, context = request.cr, request.uid, request.context
pol = request.registry('purchase.order.line')
res = {'result': False}
try:
pol.update_line(cr, uid, line_id, data, context=context)
res['result'] = True
except ValueError as e:
res['result'] = False
res['message'] = e.message
return res
def process_form(self, task_id, *args, **kw):
cr, uid, context = request.cr, request.uid, request.context
activity_api = request.registry('nh.activity')
kw_copy = kw.copy()
del kw_copy['taskId']
kw_copy['date_started'] = datetime.fromtimestamp(
int(kw_copy['startTimestamp'])).strftime(DTF)
del kw_copy['startTimestamp']
activity_api.submit(cr, uid, int(task_id), kw_copy, context)
activity_api.complete(cr, uid, int(task_id), context)
return utils.redirect(URLS['task_list'])
def cancel_reasons(self, *args, **kw):
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Reason for cancelling task?',
description='Please state reason for cancelling task',
data=api_pool.get_cancel_reasons(cr, uid, context=context))
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def session_close(self):
cr, uid, context = request.cr, request.uid, request.context
is_manager = is_user = None
pos_session = request.registry('pos.session')
ids= pos_session.search(cr, uid, [('state','<>','closed'), ('user_id','=',uid)], context=context)
id = ids and ids[0] or False
is_manager = request.registry('ir.model.access').check_groups(cr, uid, "point_of_sale.group_pos_manager")
result = {'result': True,'is_manager': is_manager, 'is_user':is_user}
if not is_manager:
is_user = request.registry('ir.model.access').check_groups(cr, uid, "point_of_sale.group_pos_user")
result["is_user"] = is_user
if id and is_user:
pos_browse = pos_session.browse(cr, uid, id, context=context)
pos_browse.signal_workflow('cashbox_control')
pos_browse.signal_workflow('close')
return result
if id and is_manager:
return result
result['result'] = False
return result
def get_partial_reasons(self, *args, **kw):
observation = kw.get('observation')
obs_pool = request.registry(
'nh.clinical.patient.observation.{0}'.format(observation))
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Reason for partial observation',
description='Please state reason for submitting '
'partial observation',
data=obs_pool._partial_reasons)
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def cancel_reasons(self, *args, **kw):
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Why is this action not required?',
description='Please state the reason '
'why this action is not required',
data=api_pool.get_cancel_reasons(cr, uid, context=context))
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def cancel_clinical(self, *args, **kw):
task_id = kw.get('task_id') # TODO: add a check if is None (?)
cr, uid = request.cr, request.uid
api_pool = request.registry('nh.eobs.api')
kw_copy = kw.copy() if kw else {}
data_timestamp = kw_copy.get('startTimestamp', None)
data_task_id = kw_copy.get('taskId', None)
if data_timestamp is not None:
del kw_copy['startTimestamp']
if data_task_id is not None:
del kw_copy['taskId']
for key, value in kw_copy.items():
if not value:
del kw_copy[key]
# Try to get the cancel reason and add it to the dict if successful.
cancel_reason = kw_copy.get('reason')
if cancel_reason:
kw_copy['reason'] = int(cancel_reason)
try:
api_pool.cancel(cr, uid, int(task_id), kw_copy)
except osv.except_osv:
response_data = {
'error': 'The server returned an error while trying '
'to cancel the task.'
}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_ERROR,
title='Cancellation unsuccessful',
description='Unable to cancel the notification',
data=response_data
)
return request.make_response(
response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE
)
response_data = {'related_tasks': [], 'status': 4}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Cancellation successful',
description='The notification was successfully cancelled',
data=response_data
)
return request.make_response(
response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE
)
def cancel_reasons(self, *args, **kw):
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Reason for cancelling task?',
description='Please state reason for cancelling task',
data=api_pool.get_cancel_reasons(cr, uid, context=context)
)
return request.make_response(
response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE
)
def purchase_order_approve(self, order_id, **data):
cr, uid, context = request.cr, request.uid, request.context
purchase_obj = request.registry('purchase.order')
res = {'result': False}
try:
purchase_obj.signal_workflow(cr,
uid, [order_id],
'purchase_approve',
context=context)
res['result'] = True
except ValueError as e:
res['result'] = False
res['message'] = e.message
return res
def confirm_clinical(self, *args, **kw):
task_id = kw.get('task_id') # TODO: add a check if is None (?)
cr, uid, context = request.cr, request.uid, request.context
api = request.registry('nh.eobs.api')
activity_api = request.registry('nh.activity')
kw_copy = kw.copy() if kw else {}
if 'taskId' in kw_copy:
del kw_copy['taskId']
if 'frequency' in kw_copy:
kw_copy['frequency'] = int(kw_copy['frequency'])
if 'location_id' in kw_copy:
kw_copy['location_id'] = int(kw_copy['location_id'])
# TODO: add a check if method 'complete' fails(?)
api.complete(cr, uid, int(task_id), kw_copy)
triggered_ids = activity_api.search(
cr, uid,
[['creator_id', '=', int(task_id)]]
)
triggered_tasks_read = activity_api.read(cr, uid, triggered_ids, [])
triggered_tasks = []
for trig_task in triggered_tasks_read:
access = api.check_activity_access(cr, uid, trig_task['id'],
context=context)
is_not_ob = 'ews' not in trig_task['data_model']
if access and is_not_ob:
triggered_tasks.append(trig_task)
response_data = {'related_tasks': triggered_tasks, 'status': 1}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Submission successful',
description='The notification was successfully submitted',
data=response_data
)
return request.make_response(
response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE
)
def get_partial_reasons(self, *args, **kw):
observation = kw.get('observation')
obs_pool = request.registry(
'nh.clinical.patient.observation.{0}'.format(observation))
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Reason for partial observation',
description='Please state reason for submitting '
'partial observation',
data=obs_pool._partial_reasons
)
return request.make_response(
response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE
)
def group_quit(self, **kw):
res = utils.init_response_data()
try:
project_task = request.registry("project.task")
uid = request.uid
group_id = int(kw.get("group_id", 0))
if not group_id:
res["code"] = status.Status.PARMAS_ERROR
return res
join_user_id_list = json.loads(kw.get("uid_list", '[]'))
project_task.quit_group(request, uid, group_id, join_user_id_list)
except Exception, e:
res["code"] = status.Status.ERROR
res["error_info"] = str(e)
return res
def group_quit(self,**kw):
res = utils.init_response_data()
try :
project_task = request.registry("project.task")
uid = request.uid
group_id = int(kw.get("group_id",0))
if not group_id :
res["code"] = status.Status.PARMAS_ERROR
return res
join_user_id_list = json.loads(kw.get("uid_list",'[]'))
project_task.quit_group(request,uid,group_id,join_user_id_list)
except Exception,e :
res["code"] = status.Status.ERROR
res["error_info"] = str(e)
return res
def get_patient_obs(self, *args, **kw):
patient_id = kw.get('patient_id') # TODO: add a check if is None (?)
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
patient_list = api_pool.get_patients(cr, uid, [int(patient_id)])
if len(patient_list) > 0:
patient = patient_list[0]
ews = api_pool.get_activities_for_patient(
cr, uid,
patient_id=int(patient_id),
activity_type='ews'
)
for ew in ews:
for e in ew:
if e in ['date_terminated', 'create_date',
'write_date', 'date_started']:
if not ew[e]:
continue
ew[e] = fields.datetime.context_timestamp(
cr, uid, datetime.strptime(ew[e], DTF),
context=context
).strftime(DTF)
response_data = {
'obs': ews,
'obsType': 'ews'
}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='{0}'.format(patient['full_name']),
description='Observations for {0}'.format(
patient['full_name']
),
data=response_data
)
else:
response_data = {'error': 'Patient not found.'}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_ERROR,
title='Patient not found',
description='Unable to find patient with ID provided',
data=response_data
)
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def cancel_clinical(self, *args, **kw):
task_id = kw.get('task_id') # TODO: add a check if is None (?)
cr, uid = request.cr, request.uid
api_pool = request.registry('nh.eobs.api')
kw_copy = kw.copy() if kw else {}
data_timestamp = kw_copy.get('startTimestamp', None)
data_task_id = kw_copy.get('taskId', None)
if data_timestamp is not None:
del kw_copy['startTimestamp']
if data_task_id is not None:
del kw_copy['taskId']
for key, value in kw_copy.items():
if not value:
del kw_copy[key]
# Try to get the cancel reason and add it to the dict if successful.
cancel_reason = kw_copy.get('reason')
if cancel_reason:
kw_copy['reason'] = int(cancel_reason)
try:
api_pool.cancel(cr, uid, int(task_id), kw_copy)
except osv.except_osv:
response_data = {
'error':
'The server returned an error while trying '
'to cancel the task.'
}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_ERROR,
title='Cancellation unsuccessful',
description='Unable to cancel the notification',
data=response_data)
return request.make_response(
response_json, headers=ResponseJSON.HEADER_CONTENT_TYPE)
response_data = {'related_tasks': [], 'status': 4}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Cancellation successful',
description='The notification was successfully cancelled',
data=response_data)
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def rapid_tranq(self, *args, **kwargs):
"""
Endpoint for reading and writing the `rapid_tranq` field on a patient's
spell.
Let's the API model create the JSON encoded response and simply wraps
it in a response object to be returned to the client.
:param args:
:param kwargs:
:return:
"""
api_model = request.registry('nh.eobs.api')
response = api_model.set_rapid_tranq(request.cr, request.uid, request,
**kwargs)
return request.make_response(response,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def rapid_tranq(self, *args, **kwargs):
"""
Endpoint for reading and writing the `rapid_tranq` field on a patient's
spell.
Let's the API model create the JSON encoded response and simply wraps
it in a response object to be returned to the client.
:param args:
:param kwargs:
:return:
"""
api_model = request.registry('nh.eobs.api')
response = api_model.set_rapid_tranq(request.cr, request.uid, request,
**kwargs)
return request.make_response(response,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def get_patient_obs(self, *args, **kw):
patient_id = kw.get('patient_id') # TODO: add a check if is None (?)
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
patient_list = api_pool.get_patients(cr, uid, [int(patient_id)])
if len(patient_list) > 0:
patient = patient_list[0]
ews = api_pool.get_activities_for_patient(
cr, uid, patient_id=int(patient_id), activity_type='ews')
for ew in ews:
for e in ew:
if e in [
'date_terminated', 'create_date', 'write_date',
'date_started'
]:
if not ew[e]:
continue
ew[e] = fields.datetime.context_timestamp(
cr,
uid,
datetime.strptime(ew[e], DTF),
context=context).strftime(DTF)
response_data = {'obs': ews, 'obsType': 'ews'}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='{0}'.format(patient['full_name']),
description='Observations for {0}'.format(
patient['full_name']),
data=response_data)
else:
response_data = {'error': 'Patient not found.'}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_ERROR,
title='Patient not found',
description='Unable to find patient with ID provided',
data=response_data)
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def get_task_form(self, cr, uid, task, patient, request, context=None):
"""
Get the form for a task
:param task: task object
:return: tuple of form and form inputs
"""
activity_model = request.registry('nh.activity')
activity_record = activity_model.browse(cr, uid, task.get('id'))
form_desc, form = self.process_form_fields(
activity_record.data_ref.get_form_description(patient.get('id')))
form['action'] = \
URLS['task_form_action'] + '{0}'.format(task.get('id'))
# Add data model changing bit here
model_name = task['data_model']
form['type'] = model_name[(model_name.rindex('.') + 1):]
form['task-id'] = task.get('id')
form['patient-id'] = \
int(patient['id']) if patient and patient.get('id') else False
form['source'] = "task"
form['start'] = datetime.now().strftime('%s')
return form, form_desc
def get_task_form(self, cr, uid, task, patient, request, context=None):
"""
Get the form for a task
:param task: task object
:return: tuple of form and form inputs
"""
api_reg = request.registry('nh.eobs.api')
form_desc, form = self.process_form_fields(
api_reg.get_form_description(cr,
uid,
patient.get('id'),
task.get('data_model'),
context=context))
form['action'] = \
URLS['task_form_action'] + '{0}'.format(task.get('id'))
form['type'] = task['data_model']
form['task-id'] = task.get('id')
form['patient-id'] = \
int(patient['id']) if patient and patient.get('id') else False
form['source'] = "task"
form['start'] = datetime.now().strftime('%s')
return form, form_desc
def get_task_form(self, cr, uid, task, patient, request, context=None):
"""
Get the form for a task
:param task: task object
:return: tuple of form and form inputs
"""
activity_model = request.registry('nh.activity')
activity_record = activity_model.browse(cr, uid, task.get('id'))
form_desc, form = self.process_form_fields(
activity_record.data_ref.get_form_description(patient.get('id'))
)
form['action'] = \
URLS['task_form_action'] + '{0}'.format(task.get('id'))
# Add data model changing bit here
model_name = task['data_model']
form['type'] = model_name[(model_name.rindex('.') + 1):]
form['task-id'] = task.get('id')
form['patient-id'] = \
int(patient['id']) if patient and patient.get('id') else False
form['source'] = "task"
form['start'] = datetime.now().strftime('%s')
return form, form_desc
def get_patient_obs(self, *args, **kw):
patient_id = kw.get('patient_id') # TODO: add a check if is None (?)
obs_type = kw.get('obs_type')
cr, uid = request.cr, request.uid
api_pool = request.registry('nh.eobs.api')
patient_list = api_pool.get_patients(cr, uid, [int(patient_id)])
if len(patient_list) > 0:
patient = patient_list[0]
observations = api_pool.get_activities_for_patient(
cr, uid,
patient_id=int(patient_id),
activity_type=obs_type
)
observations.reverse()
response_data = {
'obs': observations,
'obsType': obs_type
}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='{0}'.format(patient['full_name']),
description='Observations for {0}'.format(
patient['full_name']
),
data=response_data
)
else:
response_data = {'error': 'Data not found.'}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_ERROR,
title='Data not found',
description='Unable to find data with ID and ob name provided',
data=response_data
)
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def process_patient_observation_form(self, *args, **kw):
# TODO: add a check if is None (?)
obs_model_name = kw.get('observation')
# TODO: add a check if is None (?)
patient_id = kw.get('patient_id')
cr, uid, context = request.cr, request.uid, request.context
api = request.registry('nh.eobs.api')
activity_api = request.registry('nh.activity')
obs_str = 'nh.clinical.patient.observation.' + obs_model_name
observation_pool = request.registry(obs_str)
converter_pool = request.registry('ir.fields.converter')
converter = converter_pool.for_model(cr,
uid,
observation_pool,
str,
context=context)
kw_copy = kw.copy() if kw else {}
data_timestamp = kw_copy.get('startTimestamp', False)
data_task_id = kw_copy.get('taskId', False)
data_device_id = kw_copy.get('device_id', False)
data_recorded_concerns = kw_copy.get('recorded_concerns', False)
data_dietary_needs = kw_copy.get('dietary_needs', False)
if data_timestamp:
del kw_copy['startTimestamp']
if data_task_id:
del kw_copy['taskId']
if obs_model_name is not None:
del kw_copy['observation']
if patient_id is not None:
del kw_copy['patient_id']
if data_device_id:
del kw_copy['device_id']
if data_recorded_concerns:
del kw_copy['recorded_concerns']
if data_dietary_needs:
del kw_copy['dietary_needs']
for key, value in kw_copy.items():
if not value:
del kw_copy[key]
converted_data = converter(kw_copy, _logger.debug)
if data_timestamp:
converted_data['date_started'] = datetime.fromtimestamp(
int(data_timestamp)).strftime(DTF)
if data_device_id:
converted_data['device_id'] = data_device_id
if data_recorded_concerns:
converted_data['recorded_concerns'] = \
[[6, 0, map(int, data_recorded_concerns.split(','))]]
if data_dietary_needs:
converted_data['dietary_needs'] = \
[[6, 0, map(int, data_dietary_needs.split(','))]]
vals_data = {}
if obs_model_name == 'neurological':
if 'eyes' in converted_data:
vals_data['eyes'] = converted_data['eyes']
if 'verbal' in converted_data:
vals_data['verbal'] = converted_data['verbal']
if 'motor' in converted_data:
vals_data['motor'] = converted_data['motor']
# elif obs_model_name == 'food_fluid':
# if 'passed_urine' in converted_data:
# vals_data['passed_urine'] = converted_data['passed_urine']
# if 'bowels_open' in converted_data:
# vals_data['bowels_open'] = converted_data['bowels_open']
else:
vals_data = converted_data
new_activity_id = api.create_activity_for_patient(cr,
uid,
int(patient_id),
obs_model_name,
vals_data=vals_data,
context=context)
api.complete(cr, uid, int(new_activity_id), converted_data, context)
new_activity = activity_api.browse(cr, uid, new_activity_id)
obs = new_activity.data_ref
description = self.get_submission_message(obs)
response_data = obs.get_submission_response_data()
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Successfully Submitted{0} {1}'.format(
' Partial' if obs.is_partial else '',
observation_pool.get_description()),
description=description,
data=response_data)
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def take_patient_observation(self, observation, patient_id, *args, **kw):
"""
Renders the
:class:`observation<observations.nh_clinical_patient_observation>`
entry view.
:returns: observations entry response object
:rtype: :class:`http.Response<openerp.http.Response>`
"""
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
follow_activities = api_pool.get_assigned_activities(
cr,
uid,
activity_type='nh.clinical.patient.follow',
context=context)
patient = dict()
patient_info = api_pool.get_patients(cr,
uid, [int(patient_id)],
context=context)
if not patient_info:
exceptions.abort(404)
elif len(patient_info) > 0:
patient_info = patient_info[0]
patient['url'] = URLS['single_patient'] + '{0}'.format(
patient_info['id'])
patient['name'] = patient_info['full_name']
patient['id'] = patient_info['id']
ob_model_name = \
'nh.clinical.patient.observation.{0}'.format(observation)
form_desc, form = self.process_form_fields(
api_pool.get_form_description(cr,
uid,
int(patient_id),
ob_model_name,
context=context))
ob_rec = request.registry(ob_model_name)
view_desc = ob_rec.new(cr, uid).get_view_description(form_desc)
form['action'] = URLS['patient_form_action'] + '{0}/{1}'.format(
observation, patient_id)
form['type'] = observation
form['task-id'] = False
form['patient-id'] = int(patient_id)
form['source'] = "patient"
form['start'] = datetime.now().strftime('%s')
observation_name_list = []
for ob in api_pool.get_active_observations(cr, uid, patient_id):
if ob['type'] == observation:
observation_name_list.append(ob['name'])
if len(observation_name_list) == 0:
exceptions.abort(404)
return request.render('nh_eobs_mobile.data_input_screen',
qcontext={
'view_description': view_desc,
'name': observation_name_list[0],
'patient': patient,
'form': form,
'section': 'patient',
'notification_count': len(follow_activities),
'username': request.session['login'],
'urls': URLS,
'task_valid': True
})
def take_patient_observation(self, observation, patient_id, *args, **kw):
"""
Renders the
:class:`observation<observations.nh_clinical_patient_observation>`
entry view.
:returns: observations entry response object
:rtype: :class:`http.Response<openerp.http.Response>`
"""
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
follow_activities = api_pool.get_assigned_activities(
cr, uid,
activity_type='nh.clinical.patient.follow',
context=context)
patient = dict()
patient_info = api_pool.get_patients(
cr, uid, [int(patient_id)], context=context)
if not patient_info:
exceptions.abort(404)
elif len(patient_info) > 0:
patient_info = patient_info[0]
patient['url'] = URLS['single_patient'] + '{0}'.format(
patient_info['id'])
patient['name'] = patient_info['full_name']
patient['id'] = patient_info['id']
form = dict()
form['action'] = URLS['patient_form_action']+'{0}/{1}'.format(
observation, patient_id)
form['type'] = observation
form['task-id'] = False
form['patient-id'] = int(patient_id)
form['source'] = "patient"
form['start'] = datetime.now().strftime('%s')
form['obs_needs_score'] = False
form_desc = api_pool.get_form_description(
cr, uid, int(patient_id),
'nh.clinical.patient.observation.{0}'.format(observation),
context=context)
for form_input in form_desc:
if form_input['type'] in ['float', 'integer']:
input_type = form_input['type']
form_input['step'] = 0.1 if input_type is 'float' else 1
form_input['type'] = 'number'
form_input['number'] = True
form_input['info'] = ''
form_input['errors'] = ''
form_input['min'] = str(form_input['min'])
elif form_input['type'] == 'selection':
form_input['selection_options'] = []
form_input['info'] = ''
form_input['errors'] = ''
for option in form_input['selection']:
opt = dict()
opt['value'] = '{0}'.format(option[0])
opt['label'] = option[1]
form_input['selection_options'].append(opt)
elif form_input['type'] == 'meta':
obs_score = form_input['score']
score_present = 'score' in form_input
form['obs_needs_score'] = obs_score if score_present else False
observation_name_list = []
for ob in api_pool._active_observations:
if ob['type'] == observation:
observation_name_list.append(ob['name'])
if len(observation_name_list) == 0:
exceptions.abort(404)
return request.render(
'nh_eobs_mobile.observation_entry',
qcontext={
'inputs': form_desc,
'name': observation_name_list[0],
'patient': patient,
'form': form,
'section': 'patient',
'notification_count': len(follow_activities),
'username': request.session['login'],
'urls': URLS
}
)
def web_login(self, redirect=None, **kw):
ensure_db()
if request.httprequest.method == 'GET' and redirect and request.session.uid:
return http.redirect_with_hash(redirect)
if not request.uid:
request.uid = openerp.SUPERUSER_ID
values = request.params.copy()
if not redirect:
redirect = '/web?' + request.httprequest.query_string
values['redirect'] = redirect
try:
values['databases'] = http.db_list()
except openerp.exceptions.AccessDenied:
values['databases'] = None
if request.httprequest.method == 'POST':
old_uid = request.uid
uid = request.session.authenticate(request.session.db, request.params['login'], request.params['password'])
cr, context = request.cr, request.context
pos_session = request.registry('pos.session')
def check_contraints(config_id):
check, value = False,None
domain = [
('state', '!=', 'closed'),
('config_id', '=', config_id)
]
if pos_session.search_count(cr, uid, domain, context=context)>0:
check, value = True, "You cannot create two active sessions related to the same point of sale. Contact Administrator!"
domain = [
('state', 'not in', ('closed','closing_control')),
('user_id', '=', uid)
]
if pos_session.search_count(cr, uid, domain, context=context)>0:
check, value = True, "You cannot create two active sessions with the same responsible. Contact Administrator!"
return check, value
if uid is not False:
user = request.registry['res.users'].browse(cr, uid, uid, context)
is_manager = request.registry('ir.model.access').check_groups(cr, uid, "point_of_sale.group_pos_manager")
if not is_manager:
is_user = request.registry('ir.model.access').check_groups(cr, uid, "point_of_sale.group_pos_user")
if is_user:
current_user = request.registry('res.users').browse(cr, uid, uid, context= context)
pos_config_id = current_user.pos_config and current_user.pos_config.id or False
if not pos_config_id:
r = request.registry('pos.config').search(cr, uid, [], context=context)
pos_config_id = r and r[0] or False
check, error = check_contraints(pos_config_id)
if check:
values['error'] = error
return request.render('web.login', values)
session_id = pos_session.create(cr, uid, {'user_id' : uid,'config_id' : pos_config_id}, context=context)
if pos_session.browse(cr, uid, session_id, context=context).state == 'opened':
redirect = redirect.replace("/web","/pos/web")
else:
#To do code for manager
pass
return http.redirect_with_hash(redirect)
request.uid = old_uid
values['error'] = "Wrong login/password"
return request.render('web.login', values)
def process_patient_observation_form(self, *args, **kw):
observation = kw.get('observation') # TODO: add a check if is None (?)
patient_id = kw.get('patient_id') # TODO: add a check if is None (?)
cr, uid, context = request.cr, request.uid, request.context
api = request.registry('nh.eobs.api')
activity_api = request.registry('nh.activity')
obs_str = 'nh.clinical.patient.observation.' + observation
observation_pool = request.registry(obs_str)
converter_pool = request.registry('ir.fields.converter')
converter = converter_pool.for_model(cr,
uid,
observation_pool,
str,
context=context)
kw_copy = kw.copy() if kw else {}
test = {}
data_timestamp = kw_copy.get('startTimestamp', False)
data_task_id = kw_copy.get('taskId', False)
data_device_id = kw_copy.get('device_id', False)
if data_timestamp:
del kw_copy['startTimestamp']
if data_task_id:
del kw_copy['taskId']
if observation is not None:
del kw_copy['observation']
if patient_id is not None:
del kw_copy['patient_id']
if data_device_id:
del kw_copy['device_id']
for key, value in kw_copy.items():
if not value:
del kw_copy[key]
converted_data = converter(kw_copy, test)
if data_timestamp:
converted_data['date_started'] = datetime.fromtimestamp(
int(data_timestamp)).strftime(DTF)
if data_device_id:
converted_data['device_id'] = data_device_id
new_activity = api.create_activity_for_patient(cr,
uid,
int(patient_id),
observation,
context=context)
api.complete(cr, uid, int(new_activity), converted_data, context)
triggered_ids = activity_api.search(
cr, uid, [['creator_id', '=', int(new_activity)]])
triggered_tasks_read = activity_api.read(cr, uid, triggered_ids, [])
triggered_tasks = []
for trig_task in triggered_tasks_read:
access = api.check_activity_access(cr, uid, trig_task['id'])
is_not_ob = observation not in trig_task['data_model']
is_open = trig_task['state'] not in ['completed', 'cancelled']
if access and is_open and is_not_ob:
triggered_tasks.append(trig_task)
partial = 'partial_reason' in kw_copy and kw_copy['partial_reason']
response_data = {'related_tasks': triggered_tasks, 'status': 1}
rel_tasks = 'Here are related tasks based on the observation' if len(
triggered_tasks) > 0 else ''
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Successfully Submitted{0} {1}'.format(
' Partial' if partial else '', observation_pool._description),
description=rel_tasks,
data=response_data)
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def process_patient_observation_form(self, *args, **kw):
# TODO: add a check if is None (?)
obs_model_name = kw.get('observation')
# TODO: add a check if is None (?)
patient_id = kw.get('patient_id')
cr, uid, context = request.cr, request.uid, request.context
api = request.registry('nh.eobs.api')
activity_api = request.registry('nh.activity')
obs_str = 'nh.clinical.patient.observation.'+obs_model_name
observation_pool = request.registry(obs_str)
converter_pool = request.registry('ir.fields.converter')
converter = converter_pool.for_model(cr, uid, observation_pool,
str, context=context)
kw_copy = kw.copy() if kw else {}
data_timestamp = kw_copy.get('startTimestamp', False)
data_task_id = kw_copy.get('taskId', False)
data_device_id = kw_copy.get('device_id', False)
if data_timestamp:
del kw_copy['startTimestamp']
if data_task_id:
del kw_copy['taskId']
if obs_model_name is not None:
del kw_copy['observation']
if patient_id is not None:
del kw_copy['patient_id']
if data_device_id:
del kw_copy['device_id']
for key, value in kw_copy.items():
if not value:
del kw_copy[key]
converted_data = converter(kw_copy, _logger.debug)
if data_timestamp:
converted_data['date_started'] = datetime.fromtimestamp(
int(data_timestamp)).strftime(DTF)
if data_device_id:
converted_data['device_id'] = data_device_id
vals_data = {}
if obs_model_name == 'neurological' or obs_model_name == 'gcs':
if 'eyes' in converted_data:
vals_data['eyes'] = converted_data['eyes']
if 'verbal' in converted_data:
vals_data['verbal'] = converted_data['verbal']
if 'motor' in converted_data:
vals_data['motor'] = converted_data['motor']
elif obs_model_name == 'food_fluid':
if 'passed_urine' in converted_data:
vals_data['passed_urine'] = converted_data['passed_urine']
if 'bowels_open' in converted_data:
vals_data['bowels_open'] = converted_data['bowels_open']
else:
vals_data = converted_data
new_activity_id = api.create_activity_for_patient(
cr, uid, int(patient_id), obs_model_name, vals_data=vals_data,
context=context
)
api.complete(cr, uid, int(new_activity_id), converted_data, context)
new_activity = activity_api.browse(cr, uid, new_activity_id)
obs = new_activity.data_ref
description = self.get_submission_message(obs)
response_data = obs.get_submission_response_data()
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Successfully Submitted{0} {1}'.format(
' Partial' if obs.is_partial else '',
observation_pool.get_description(append_observation=True)
),
description=description,
data=response_data
)
return request.make_response(
response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE
)
def shop(self, page=0, category=None, search='', **post):
cr, uid, context, pool = request.cr, request.uid, request.context, request.registry
ir_rule_obj = request.registry("ir.rule")
user_obj = request.registry("res.users")
prod_ids = ir_rule_obj.product_filter(cr, uid, [], context=context)
newdom = []
# dom = ir_rule_obj._compute_domain(cr, uid, self.name, 'read') or []
domain = request.website.sale_product_domain()
dom = []
u_id = context.get("uid", uid)
user = user_obj.browse(cr, uid, [u_id])
if user.user_roles in ('magicemart_portal_user',
'magicemart_portal_manager',
'magicemart_supplier_portal'):
if prod_ids:
newdom = [('id', 'in', [x[0] for x in prod_ids])]
else:
newdom = [('id', '=', 1)]
if len(dom):
domain = list((['&'] + dom + newdom))
else:
domain = list(newdom)
if search:
for srch in search.split(" "):
domain += [
'|', '|', '|', ('name', 'ilike', srch),
('description', 'ilike', srch),
('description_sale', 'ilike', srch),
('product_variant_ids.default_code', 'ilike', srch)
]
if category:
domain += [('public_categ_ids', 'child_of', int(category))]
attrib_list = request.httprequest.args.getlist('attrib')
attrib_values = [map(int, v.split("-")) for v in attrib_list if v]
attrib_set = set([v[1] for v in attrib_values])
if attrib_values:
attrib = None
ids = []
for value in attrib_values:
if not attrib:
attrib = value[0]
ids.append(value[1])
elif value[0] == attrib:
ids.append(value[1])
else:
domain += [('attribute_line_ids.value_ids', 'in', ids)]
attrib = value[0]
ids = [value[1]]
if attrib:
domain += [('attribute_line_ids.value_ids', 'in', ids)]
keep = WSmain.QueryURL('/shop',
category=category and int(category),
search=search,
attrib=attrib_list)
if not context.get('pricelist'):
pricelist = self.get_pricelist()
context['pricelist'] = int(pricelist)
else:
pricelist = pool.get('product.pricelist').browse(
cr, uid, context['pricelist'], context)
product_obj = pool.get('product.template')
url = "/shop"
product_count = product_obj.search_count(cr,
uid,
domain,
context=context)
if search:
post["search"] = search
if category:
category = pool['product.public.category'].browse(cr,
uid,
int(category),
context=context)
url = "/shop/category/%s" % slug(category)
pager = request.website.pager(url=url,
total=product_count,
page=page,
step=PPG,
scope=7,
url_args=post)
product_ids = product_obj.search(
cr,
uid,
domain,
limit=PPG,
offset=pager['offset'],
order='website_published desc, website_sequence desc',
context=context)
products = product_obj.browse(cr, uid, product_ids, context=context)
style_obj = pool['product.style']
style_ids = style_obj.search(cr, uid, [], context=context)
styles = style_obj.browse(cr, uid, style_ids, context=context)
category_obj = pool['product.public.category']
category_ids = category_obj.search(cr,
uid, [('parent_id', '=', False)],
context=context)
categs = category_obj.browse(cr, uid, category_ids, context=context)
attributes_obj = request.registry['product.attribute']
attributes_ids = attributes_obj.search(cr, uid, [], context=context)
attributes = attributes_obj.browse(cr,
uid,
attributes_ids,
context=context)
from_currency = pool.get('product.price.type')._get_field_currency(
cr, uid, 'list_price', context)
to_currency = pricelist.currency_id
compute_currency = lambda price: pool['res.currency']._compute(
cr, uid, from_currency, to_currency, price, context=context)
values = {
'search':
search,
'category':
category,
'attrib_values':
attrib_values,
'attrib_set':
attrib_set,
'pager':
pager,
'pricelist':
pricelist,
'products':
products,
'bins':
WSmain.table_compute().process(products),
'rows':
PPR,
'styles':
styles,
'categories':
categs,
'attributes':
attributes,
'compute_currency':
compute_currency,
'keep':
keep,
'style_in_product':
lambda style, product: style.id in
[s.id for s in product.website_style_ids],
'attrib_encode':
lambda attribs: werkzeug.url_encode([('attrib', i)
for i in attribs]),
}
return request.website.render("website_sale.products", values)
res["code"] = status.Status.ERROR
res["error_info"] = str(e)
return res
return res
@http.route('/odoo/api/task/create',type='http')
@serialize_exception
def create_group(self,**kw):
res = utils.init_response_data()
try :
name = kw.get("name","")
except Exception ,e :
res["code"] = status.Status.ERROR
res["error_info"] = str(e)
return res
project_task = request.registry("project.task")
uid = request.uid
vals = {
'message_follower_ids': False,
'sequence': 10,
'date_end': False,
'planned_hours': 0,
'partner_id': False,
'message_ids': False,
'user_id': 1,
'date_start': '2016-07-08 10:15:04',
'company_id': 1,
'priority': '0',
'project_id': False,
'date_last_stage_update': '2016-07-08 10:15:04',
'group_type': False,
def purchase_order_line_unlik(self, line_id, **data):
cr, uid, context = request.cr, request.uid, request.context
pol = request.registry('purchase.order.line')
return pol.unlink(cr, uid, [line_id], context=context)
def calculate_obs_score(self, *args, **kw):
observation = kw.get('observation') # TODO: add a check if is None (?)
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
model = 'nh.clinical.patient.observation.' + observation
converter_pool = request.registry('ir.fields.converter')
observation_pool = request.registry(model)
converter = converter_pool.for_model(cr,
uid,
observation_pool,
str,
context=context)
data = kw.copy() if kw else {}
section = 'patient'
if 'startTimestamp' in data:
del data['startTimestamp']
if 'taskId' in data:
section = 'task'
del data['taskId']
if observation is not None:
del data['observation']
if observation == 'ews':
observation = 'news'
for key, value in data.items():
if not value or key not in [
'avpu_text', 'blood_pressure_systolic',
'body_temperature', 'indirect_oxymetry_spo2',
'oxygen_administration_flag', 'pulse_rate',
'respiration_rate'
]:
del data[key]
converted_data = converter(data, _logger.debug)
score_dict = api_pool.get_activity_score(cr,
uid,
model,
converted_data,
context=context)
if not score_dict:
exceptions.abort(400)
modal_vals = {}
score_type = observation.upper() if observation != 'neurological' \
else 'Coma Scale'
# TODO: Need to add patient name in somehow
modal_vals['title'] = 'Submit {score_type} score of {score}'.format(
score_type=score_type, score=score_dict.get('score', ''))
if 'clinical_risk' in score_dict:
modal_vals['content'] = '<p><strong>' \
'Clinical risk: {risk}</strong>' \
'</p><p>' \
'Please confirm you want to ' \
'submit this score</p>'.format(
risk=score_dict['clinical_risk'])
else:
modal_vals['content'] = '<p>Please confirm you want to ' \
'submit this score</p>'
response_data = {
'score': score_dict,
'modal_vals': modal_vals,
'status': 3,
'next_action': 'json_{}_form_action'.format(section)
}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title=modal_vals['title'],
description=modal_vals['content'],
data=response_data)
return request.make_response(response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE)
def process_patient_observation_form(self, *args, **kw):
observation = kw.get('observation') # TODO: add a check if is None (?)
patient_id = kw.get('patient_id') # TODO: add a check if is None (?)
cr, uid, context = request.cr, request.uid, request.context
api = request.registry('nh.eobs.api')
activity_api = request.registry('nh.activity')
obs_str = 'nh.clinical.patient.observation.'+observation
observation_pool = request.registry(obs_str)
converter_pool = request.registry('ir.fields.converter')
converter = converter_pool.for_model(cr, uid, observation_pool,
str, context=context)
kw_copy = kw.copy() if kw else {}
test = {}
data_timestamp = kw_copy.get('startTimestamp', False)
data_task_id = kw_copy.get('taskId', False)
data_device_id = kw_copy.get('device_id', False)
if data_timestamp:
del kw_copy['startTimestamp']
if data_task_id:
del kw_copy['taskId']
if observation is not None:
del kw_copy['observation']
if patient_id is not None:
del kw_copy['patient_id']
if data_device_id:
del kw_copy['device_id']
for key, value in kw_copy.items():
if not value:
del kw_copy[key]
converted_data = converter(kw_copy, test)
if data_timestamp:
converted_data['date_started'] = datetime.fromtimestamp(
int(data_timestamp)).strftime(DTF)
if data_device_id:
converted_data['device_id'] = data_device_id
new_activity = api.create_activity_for_patient(cr, uid,
int(patient_id),
observation,
context=context)
api.complete(cr, uid, int(new_activity), converted_data, context)
triggered_ids = activity_api.search(
cr, uid,
[['creator_id', '=', int(new_activity)]]
)
triggered_tasks_read = activity_api.read(cr, uid, triggered_ids, [])
triggered_tasks = []
for trig_task in triggered_tasks_read:
access = api.check_activity_access(cr, uid, trig_task['id'])
is_not_ob = observation not in trig_task['data_model']
is_open = trig_task['state'] not in ['completed', 'cancelled']
if access and is_open and is_not_ob:
triggered_tasks.append(trig_task)
partial = 'partial_reason' in kw_copy and kw_copy['partial_reason']
response_data = {'related_tasks': triggered_tasks, 'status': 1}
rel_tasks = 'Here are related tasks based on the observation' if len(
triggered_tasks
) > 0 else ''
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title='Successfully Submitted{0} {1}'.format(
' Partial' if partial else '', observation_pool._description
),
description=rel_tasks,
data=response_data
)
return request.make_response(
response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE
)
def calculate_obs_score(self, *args, **kw):
observation = kw.get('observation') # TODO: add a check if is None (?)
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
model = 'nh.clinical.patient.observation.' + observation
converter_pool = request.registry('ir.fields.converter')
observation_pool = request.registry(model)
converter = converter_pool.for_model(
cr, uid, observation_pool, str, context=context
)
data = kw.copy() if kw else {}
section = 'patient'
if 'startTimestamp' in data:
del data['startTimestamp']
if 'taskId' in data:
section = 'task'
del data['taskId']
if observation is not None:
del data['observation']
if observation == 'ews':
observation = 'news'
for key, value in data.items():
if not value or key not in [
'avpu_text',
'blood_pressure_systolic',
'body_temperature',
'indirect_oxymetry_spo2',
'oxygen_administration_flag',
'pulse_rate',
'respiration_rate'
]:
del data[key]
converted_data = converter(data, _logger.debug)
score_dict = api_pool.get_activity_score(
cr, uid, model, converted_data, context=context
)
if not score_dict:
exceptions.abort(400)
modal_vals = {}
score_type = observation.upper() if observation != 'neurological' \
else 'Coma Scale'
# TODO: Need to add patient name in somehow
modal_vals['title'] = 'Submit {score_type} score of {score}'.format(
score_type=score_type,
score=score_dict.get('score', '')
)
if 'clinical_risk' in score_dict:
modal_vals['content'] = '<p><strong>' \
'Clinical risk: {risk}</strong>' \
'</p><p>' \
'Please confirm you want to ' \
'submit this score</p>'.format(
risk=score_dict['clinical_risk'])
else:
modal_vals['content'] = '<p>Please confirm you want to ' \
'submit this score</p>'
response_data = {
'score': score_dict,
'modal_vals': modal_vals,
'status': 3,
'next_action': 'json_{}_form_action'.format(section)
}
response_json = ResponseJSON.get_json_data(
status=ResponseJSON.STATUS_SUCCESS,
title=modal_vals['title'],
description=modal_vals['content'],
data=response_data
)
return request.make_response(
response_json,
headers=ResponseJSON.HEADER_CONTENT_TYPE
)
res["code"] = status.Status.ERROR
res["error_info"] = str(e)
return res
return res
@http.route('/odoo/api/task/create', type='http')
@serialize_exception
def create_group(self, **kw):
res = utils.init_response_data()
try:
name = kw.get("name", "")
except Exception, e:
res["code"] = status.Status.ERROR
res["error_info"] = str(e)
return res
project_task = request.registry("project.task")
uid = request.uid
vals = {
'message_follower_ids': False,
'sequence': 10,
'date_end': False,
'planned_hours': 0,
'partner_id': False,
'message_ids': False,
'user_id': 1,
'date_start': '2016-07-08 10:15:04',
'company_id': 1,
'priority': '0',
'project_id': False,
'date_last_stage_update': '2016-07-08 10:15:04',
'group_type': False,
def take_patient_observation(self, observation, patient_id, *args, **kw):
"""
Renders the
:class:`observation<observations.nh_clinical_patient_observation>`
entry view.
:returns: observations entry response object
:rtype: :class:`http.Response<openerp.http.Response>`
"""
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
follow_activities = api_pool.get_assigned_activities(
cr, uid,
activity_type='nh.clinical.patient.follow',
context=context)
patient = dict()
patient_info = api_pool.get_patients(
cr, uid, [int(patient_id)], context=context)
if not patient_info:
exceptions.abort(404)
elif len(patient_info) > 0:
patient_info = patient_info[0]
patient['url'] = URLS['single_patient'] + '{0}'.format(
patient_info['id'])
patient['name'] = patient_info['full_name']
patient['id'] = patient_info['id']
ob_model_name = \
'nh.clinical.patient.observation.{0}'.format(observation)
form_desc, form = self.process_form_fields(
api_pool.get_form_description(
cr, uid, int(patient_id),
ob_model_name,
context=context)
)
ob_rec = request.registry(ob_model_name)
view_desc = ob_rec.new(cr, uid).get_view_description(form_desc)
form['action'] = URLS['patient_form_action'] + '{0}/{1}'.format(
observation, patient_id)
form['type'] = observation
form['task-id'] = False
form['patient-id'] = int(patient_id)
form['source'] = "patient"
form['start'] = datetime.now().strftime('%s')
observation_name_list = []
for ob in api_pool.get_active_observations(cr, uid, patient_id):
if ob['type'] == observation:
observation_name_list.append(ob['name'])
if len(observation_name_list) == 0:
exceptions.abort(404)
return request.render(
'nh_eobs_mobile.data_input_screen',
qcontext={
'view_description': view_desc,
'name': observation_name_list[0],
'patient': patient,
'form': form,
'section': 'patient',
'notification_count': len(follow_activities),
'username': request.session['login'],
'urls': URLS,
'task_valid': True
}
)
def take_patient_observation(self, observation, patient_id, *args, **kw):
"""
Renders the
:class:`observation<observations.nh_clinical_patient_observation>`
entry view.
:returns: observations entry response object
:rtype: :class:`http.Response<openerp.http.Response>`
"""
cr, uid, context = request.cr, request.uid, request.context
api_pool = request.registry('nh.eobs.api')
follow_activities = api_pool.get_assigned_activities(
cr,
uid,
activity_type='nh.clinical.patient.follow',
context=context)
patient = dict()
patient_info = api_pool.get_patients(cr,
uid, [int(patient_id)],
context=context)
if not patient_info:
exceptions.abort(404)
elif len(patient_info) > 0:
patient_info = patient_info[0]
patient['url'] = URLS['single_patient'] + '{0}'.format(
patient_info['id'])
patient['name'] = patient_info['full_name']
patient['id'] = patient_info['id']
form = dict()
form['action'] = URLS['patient_form_action'] + '{0}/{1}'.format(
observation, patient_id)
form['type'] = observation
form['task-id'] = False
form['patient-id'] = int(patient_id)
form['source'] = "patient"
form['start'] = datetime.now().strftime('%s')
form['obs_needs_score'] = False
form_desc = api_pool.get_form_description(
cr,
uid,
int(patient_id),
'nh.clinical.patient.observation.{0}'.format(observation),
context=context)
for form_input in form_desc:
if form_input['type'] in ['float', 'integer']:
input_type = form_input['type']
form_input['step'] = 0.1 if input_type is 'float' else 1
form_input['type'] = 'number'
form_input['number'] = True
form_input['info'] = ''
form_input['errors'] = ''
form_input['min'] = str(form_input['min'])
elif form_input['type'] == 'selection':
form_input['selection_options'] = []
form_input['info'] = ''
form_input['errors'] = ''
for option in form_input['selection']:
opt = dict()
opt['value'] = '{0}'.format(option[0])
opt['label'] = option[1]
form_input['selection_options'].append(opt)
elif form_input['type'] == 'meta':
obs_score = form_input['score']
score_present = 'score' in form_input
form['obs_needs_score'] = obs_score if score_present else False
observation_name_list = []
for ob in api_pool._active_observations:
if ob['type'] == observation:
observation_name_list.append(ob['name'])
if len(observation_name_list) == 0:
exceptions.abort(404)
return request.render('nh_eobs_mobile.observation_entry',
qcontext={
'inputs': form_desc,
'name': observation_name_list[0],
'patient': patient,
'form': form,
'section': 'patient',
'notification_count': len(follow_activities),
'username': request.session['login'],
'urls': URLS
})
