def get(self, category=None, name=''):
f_params = utility_get_par.parse_args()
rcds = utl_svc.utility_s_filter(f_params,
joined_keys=[
"fk_dict_utility_main_group",
"fk_dict_utility_sub_group"
])
return render_data(rcds)
def post(self):
params = session_add_par.parse_args()
session_proc = session_processor(params)
# TODO: gen instance_id
# ...
ss_id = session_proc.add()
if (params.get("session_inputs")):
session_init(ss_id, params)
# process session
session_process()
return render_data(ss_id)
def get(self, task_id):
#
obj = task_processor.fetch(task_id)
return render_data(obj)
def put(self, task_id):
params = task_put_par.parse_args()
rcd = task_processor.update(task_id, params)
return render_data(rcd)
def put(self, session_output_id):
params = session_output_put_par.parse_args()
session_output_db_proc = session_output_processor(params)
ret = session_output_db_proc.update(
unique_keys=["session_id", "index"])
return render_data(ret)
def get(self):
f_params = session_get_par.parse_args()
rcds = session_s_filer(f_params)
return render_data(rcds)
def put(self, instance_id):
params = session_put_par.parse_args()
rcd = session_processor.update(instance_id, params)
return render_data(rcd)
def get(self, instance_id):
f_params = {"instance_id": instance_id}
rcds = session_output_processor.get(f_params)
return render_data(rcds)
def get(self, category=None, name=''):
f_params = program_get_par.parse_args()
rcds = program_processor.get(f_params)
return render_data(rcds)
def get(self, category=None, name=''):
f_params = task_get_par.parse_args()
rcds = task_processor.get(f_params,
joined_keys=["task_inputs", "task_outputs"])
return render_data(rcds)
def delete(self, program_id, session=sss):
program_processor.delete(program_id)
return render_data(program_id)
def post(self):
params = program_add_par.parse_args()
program_proc = program_processor(params)
rcd = program_proc.add()
return render_data(rcd)
def put(self, program_id):
params = program_put_par.parse_args()
ret = program_processor.update(program_id, params)
return render_data(ret)
def get(self, program_id):
#
obj = program_processor.fetch(program_id)
return render_data(obj)
def delete(self, session_id):
session_processor.delete(session_id, session=sss)
return render_data(session_id)
def delete(self, task_id, session=sss):
task_processor.delete(task_id)
return render_data(task_id)
def get(self, dict_id):
#
obj = pub_dict_processor.fetch(dict_id)
return render_data(obj)
def post(self):
params = task_add_par.parse_args()
task_proc = task_processor(params)
rcd = task_proc.add()
return render_data(rcd)
def delete(self, dict_id, session=sss):
obj = pub_dict_processor.fetch(dict_id, to_user_obj=False)
session.delete(obj)
return render_data(dict_id)
def get(self, category=None, name=""):
f_params = dict_get_par.parse_args()
rcds = pub_dict_processor.get(f_params)
return render_data(rcds)
def get(self, instance_id):
#
obj = session_processor.fetch(instance_id)
return render_data(obj)
def put(self, dict_id):
params = dict_put_par.parse_args()
rcd = pub_dict_processor.update(dict_id, params)
return render_data(rcd)
def get(self, utility_id):
#
obj = utility_processor.fetch(utility_id)
return render_data(obj)
def post(self):
params = dict_add_par.parse_args()
pub_dict_proc = pub_dict_processor(params)
rcd = pub_dict_proc.add(unique_keys=["name", "category"])
return render_data(rcd)
def put(self, utility_id):
params = utility_put_par.parse_args()
utility_db_proc = utility_processor(params)
ret = utility_db_proc.update(unique_keys=["name"])
return render_data(ret)
def get(self, session_output_key):
#
obj = session_output_processor.fetch(
{"key": session_output_key})
return render_data(obj)
def delete(self, utility_id, session=sss):
obj = utility_processor.fetch(utility_id, to_user_obj=False)
session.delete(obj)
return render_data(utility_id)
def delete(self, session_output_id, session=sss):
obj = session_output_processor.fetch(
session_output_id, to_user_obj=False)
session.delete(obj)
return render_data(session_output_id)
def post(self):
params = utility_add_par.parse_args()
utility_proc = utility_processor(params)
rcd = utility_proc.add(unique_keys=["name"])
return render_data(rcd)
