def post(self): result = '[]' with SctpClientInstance() as sctp_client: cmd_addr = ScAddr.parse_from_string(self.get_argument(u'cmd', None)) # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg = ScAddr.parse_from_string(self.get_argument(u'%d_' % idx, None)) if arg is not None: # check if sc-element exist if sctp_client.check_element(arg): arguments.append(arg) else: return logic.serialize_error(404, "Invalid argument: %s" % arg) first = False idx += 1 keys = Keynodes(sctp_client) result = logic.do_command(sctp_client, keys, cmd_addr, arguments, self) self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def post(self): result = '[]' with SctpClientInstance() as sctp_client: cmd_addr = ScAddr.parse_from_string(self.get_argument( u'cmd', None)) # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg = ScAddr.parse_from_string( self.get_argument(u'%d_' % idx, None)) if arg is not None: # check if sc-element exist if sctp_client.check_element(arg): arguments.append(arg) else: return logic.serialize_error( 404, "Invalid argument: %s" % arg) first = False idx += 1 keys = Keynodes(sctp_client) result = logic.do_command(sctp_client, keys, cmd_addr, arguments, self) self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def post(self): # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg_str = u'%d_' % idx arg = self.get_argument(arg_str, None) if arg is not None: arguments.append(arg) first = False idx += 1 with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) res = {} for addr in arguments: tooltip = logic.find_tooltip(ScAddr.parse_from_string(addr), sctp_client, keys, sc_session.get_used_language()) res[addr] = tooltip self.set_header("Content-Type", "application/json") self.finish(json.dumps(res))
def info_tooltip(request): result = '[]' if request.is_ajax(): sctp_client = new_sctp_client() # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg_str = u'%d_' % idx arg = request.POST.get(arg_str, None) if arg is not None: arguments.append(arg) first = False idx += 1 keys = Keynodes(sctp_client) sc_session = logic.ScSession(request.user, request.session, sctp_client, keys) res = {} for addr in arguments: tooltip = find_tooltip(ScAddr.parse_from_string(addr), sctp_client, keys, sc_session.get_used_language()) res[addr] = tooltip result = json.dumps(res) return HttpResponse(result, 'application/json')
def post(self): lang_addr = ScAddr.parse_from_string(self.get_argument(u'lang_addr', None)) with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) sc_session.set_current_lang_mode(lang_addr) self.finish()
def post(self): lang_addr = ScAddr.parse_from_string(self.get_argument(u'lang_addr', None)) sctp_client = new_sctp_client() keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) sc_session.set_current_lang_mode(lang_addr) sctp_client.shutdown() self.set_header("Content-Type", "application/json") self.finish()
def set_language(request): if (request.is_ajax()): lang_addr = ScAddr.parse_from_string(request.POST.get(u'lang_addr', None)) sctp_client = new_sctp_client() keys = Keynodes(sctp_client) sc_session = logic.ScSession(request.user, request.session, sctp_client, keys) sc_session.set_current_lang_mode(lang_addr) result = json.dumps('') return HttpResponse(result, 'application/json')
def link_content(request): result = '{}' if True: # request.is_ajax(): sctp_client = new_sctp_client() keys = Keynodes(sctp_client) keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_nrel_mimetype = keys[KeynodeSysIdentifiers.nrel_mimetype] # parse arguments addr = ScAddr.parse_from_string(request.GET.get('addr', None)) if addr is None: return serialize_error(404, 'Invalid arguments') result = sctp_client.get_link_content(addr) if result is None: return serialize_error(404, 'Content not found') mimetype_str = u'text/plain' # determine format and mimetype format = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_format ) if format is not None: # fetermine mimetype mimetype = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, format[0][2], ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_link, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_mimetype ) if mimetype is not None: mime_value = sctp_client.get_link_content(mimetype[0][2]) if mime_value is not None: mimetype_str = mime_value return HttpResponse(result, mimetype_str + '; charset=UTF-8')
def link_content(request): result = '{}' sctp_client = new_sctp_client() keys = Keynodes(sctp_client) keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_nrel_mimetype = keys[KeynodeSysIdentifiers.nrel_mimetype] # parse arguments addr = ScAddr.parse_from_string(request.GET.get('addr', None)) if addr is None: return serialize_error(404, 'Invalid arguments') result = sctp_client.get_link_content(addr) if result is None: return serialize_error(404, 'Content not found') return HttpResponse(result, get_link_mime(addr, keynode_nrel_format, keynode_nrel_mimetype, sctp_client) + '; charset=UTF-8')
def get(self): with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_nrel_mimetype = keys[KeynodeSysIdentifiers.nrel_mimetype] # parse arguments addr = ScAddr.parse_from_string(self.get_argument('addr', None)) if addr is None: return logic.serialize_error(self, 404, 'Invalid arguments') result = sctp_client.get_link_content(addr) if result is None: return logic.serialize_error(self, 404, 'Content not found') self.set_header("Content-Type", logic.get_link_mime(addr, keynode_nrel_format, keynode_nrel_mimetype, sctp_client)) self.finish(result)
def get(self): with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_nrel_mimetype = keys[KeynodeSysIdentifiers.nrel_mimetype] # parse arguments addr = ScAddr.parse_from_string(self.get_argument('addr', None)) if addr is None: return serialize_error(self, 404, 'Invalid arguments') result = sctp_client.get_link_content(addr) if result is None: return serialize_error(self, 404, 'Content not found') self.set_header("Content-Type", logic.get_link_mime(addr, keynode_nrel_format, keynode_nrel_mimetype, sctp_client)) self.finish(result)
def link_format(request): result = '{}' if request.is_ajax(): sctp_client = new_sctp_client() # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg_str = u'%d_' % idx arg = ScAddr.parse_from_string(request.POST.get(arg_str, None)) if arg is not None: arguments.append(arg) first = False idx += 1 keys = Keynodes(sctp_client) keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_format_txt = keys[KeynodeSysIdentifiers.format_txt] result = {} for arg in arguments: # try to resolve format format = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, arg, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_format ) if format is not None: result[arg.to_id()] = format[0][2].to_id() else: result[arg.to_id()] = keynode_format_txt.to_id() result = json.dumps(result) return HttpResponse(result, 'application/json')
def post(self): sctp_client = new_sctp_client() # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg_str = u'%d_' % idx arg = ScAddr.parse_from_string(self.get_argument(arg_str, None)) if arg is not None: arguments.append(arg) first = False idx += 1 keys = Keynodes(sctp_client) keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_format_txt = keys[KeynodeSysIdentifiers.format_txt] result = {} for arg in arguments: # try to resolve format format = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, arg, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_format ) if format is not None: result[arg.to_id()] = format[0][2].to_id() else: result[arg.to_id()] = keynode_format_txt.to_id() sctp_client.shutdown() self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def post(self): result = None # get arguments idx = 1 arguments = [] arg = '' while arg is not None: arg = self.get_argument(u'%d_' % idx, None) if arg is not None: arguments.append(arg) idx += 1 sctp_client = new_sctp_client() keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) used_lang = sc_session.get_used_language() result = {} # get requested identifiers for arguments for addr_str in arguments: addr = ScAddr.parse_from_string(addr_str) if addr is None: self.clear() self.set_status(404) self.finish('Can\'t parse sc-addr from argument: %s' % addr_str) found = False idtf_value = logic.get_identifier_translated(addr, used_lang, keys, sctp_client) if idtf_value: result[addr_str] = idtf_value sctp_client.shutdown() self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def post(self): result = None # get arguments idx = 1 arguments = [] arg = '' while arg is not None: arg = self.get_argument(u'%d_' % idx, None) if arg is not None: arguments.append(arg) idx += 1 with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) used_lang = sc_session.get_used_language() result = {} # get requested identifiers for arguments for addr_str in arguments: addr = ScAddr.parse_from_string(addr_str) if addr is None: self.clear() self.set_status(404) self.finish('Can\'t parse sc-addr from argument: %s' % addr_str) found = False idtf_value = logic.get_identifier_translated( addr, used_lang, keys, sctp_client) if idtf_value: result[addr_str] = idtf_value self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def idtf_resolve(request): result = None if request.is_ajax(): # get arguments idx = 1 arguments = [] arg = '' while arg is not None: arg = request.POST.get(u'%d_' % idx, None) if arg is not None: arguments.append(arg) idx += 1 sctp_client = new_sctp_client() keys = Keynodes(sctp_client) sc_session = logic.ScSession(request.user, request.session, sctp_client, keys) used_lang = sc_session.get_used_language() result = {} # get requested identifiers for arguments for addr_str in arguments: addr = ScAddr.parse_from_string(addr_str) if addr is None: print 'Can\'t parse sc-addr from argument: %s' % addr_str return serialize_error(404, 'Can\'t parse sc-addr from argument: %s' % addr_str) found = False idtf_value = get_identifier_translated(addr, used_lang, keys, sctp_client) if idtf_value: result[addr_str] = idtf_value result = json.dumps(result) return HttpResponse(result, 'application/json')
def send(self, message): cmd = json.loads(message) cmdCode = cmd['cmdCode'] def response_message(resCode, res): if res is not None: r = res if isinstance(res, ScAddr): r = res.to_id() self.on_message(json.dumps({'resCode': resCode, 'result': r})) else: self.on_message(json.dumps({'resCode': resCode})) def res_code(res): if res is not None: return sctp.types.SctpResultCode.SCTP_RESULT_OK return sctp.types.SctpResultCode.SCTP_RESULT_FAIL if cmdCode == sctp.types.SctpCommandType.SCTP_CMD_CHECK_ELEMENT: response_message(res_code(sctp.types.ScAddr.parse_from_string(cmd['args'][0])), None) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_FIND_ELEMENT_BY_SYSITDF: res = self.sctp_client.find_element_by_system_identifier(str(cmd['args'][0])) response_message(res_code(res), res) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_GET_ELEMENT_TYPE: res = self.sctp_client.get_element_type(sctp.types.ScAddr.parse_from_string(cmd['args'][0])) response_message(res_code(res), res) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_GET_ARC: res = self.sctp_client.get_arc(sctp.types.ScAddr.parse_from_string(cmd['args'][0])) response_message(res_code(res), [res[0].to_id(), res[1].to_id()]) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_GET_LINK_CONTENT: res = self.sctp_client.get_link_content(sctp.types.ScAddr.parse_from_string(cmd['args'][0])) response_message(res_code(res), res) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_ITERATE_ELEMENTS: resCode = sctp.types.SctpResultCode.SCTP_RESULT_FAIL res = None itType = cmd['args'][0] args = cmd['args'][1:] if itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_3A_A_F: res = self.sctp_client.iterate_elements(itType, args[0], args[1], sctp.types.ScAddr.parse_from_string(args[2])) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_3F_A_A: res = self.sctp_client.iterate_elements(itType, sctp.types.ScAddr.parse_from_string(args[0]), args[1], args[2]) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_3F_A_F: res = self.sctp_client.iterate_elements(itType, sctp.types.ScAddr.parse_from_string(args[0]), args[1], sctp.types.ScAddr.parse_from_string(args[2])) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_A: res = self.sctp_client.iterate_elements(itType, args[0], args[1], sctp.types.ScAddr.parse_from_string(args[2]), args[3], args[4]) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_F: res = self.sctp_client.iterate_elements(itType, args[0], args[1], sctp.types.ScAddr.parse_from_string(args[2]), args[3], sctp.types.ScAddr.parse_from_string(args[4])) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_5_F_A_A_A_A: res = self.sctp_client.iterate_elements(itType, sctp.types.ScAddr.parse_from_string(args[0]), args[1], args[2], args[3], args[4]) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_5_F_A_F_A_A: res = self.sctp_client.iterate_elements(itType, sctp.types.ScAddr.parse_from_string(args[0]), args[1], sctp.types.ScAddr.parse_from_string(args[2]), args[3], args[4]) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_5_F_A_F_A_F: res = self.sctp_client.iterate_elements(itType, sctp.types.ScAddr.parse_from_string(args[0]), args[1], sctp.types.ScAddr.parse_from_string(args[2]), args[3], sctp.types.ScAddr.parse_from_string(args[4])) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F: res = self.sctp_client.iterate_elements(itType, sctp.types.ScAddr.parse_from_string(args[0]), args[1], args[2], args[3], sctp.types.ScAddr.parse_from_string(args[4])) sres = [] if res is not None: resCode = sctp.types.SctpResultCode.SCTP_RESULT_OK # convert sc-addrs to string id's for r in res: new_data = [] for v in r: if isinstance(v, sctp.types.ScAddr): new_data.append(v.to_id()) else: new_data.append(v) sres.append(new_data) response_message(resCode, sres) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_EVENT_CREATE: eventType = cmd['args'][0] addr = sctp.types.ScAddr.parse_from_string(cmd['args'][1]) eventId = self.sctp_client.event_create(eventType, addr, self.events_callback) if eventId == None: response_message(sctp.types.SctpResultCode.SCTP_RESULT_FAIL, None) else: response_message(sctp.types.SctpResultCode.SCTP_RESULT_OK, eventId) self.registered_events.append(eventId) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_EVENT_DESTROY: eventId = cmd['args'][0] res = sctp.types.SctpResultCode.SCTP_RESULT_FAIL if self.sctp_client.event_destroy(eventId): res = sctp.types.SctpResultCode.SCTP_RESULT_OK self.registered_events.remove(eventId) response_message(res, None) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_EVENT_EMIT: self.events_lock.acquire() events = self.recieved_events self.recieved_events = [] self.events_lock.release() result = [] for evt in events: if evt[0] in self.registered_events: result.append(evt) response_message(sctp.types.SctpResultCode.SCTP_RESULT_OK, result) # @todo authorised users only elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_CREATE_NODE: res = self.sctp_client.create_node(int(cmd['args'][0])) response_message(res_code(res), res) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_CREATE_ARC: args = cmd['args'] res = self.sctp_client.create_arc(int(args[0]), ScAddr.parse_from_string(args[1]), ScAddr.parse_from_string(args[2])) response_message(res_code(res), res)
def do_command(request): result = '[]' if request.is_ajax(): #result = u'[{"type": "node", "id": "1", "identifier": "node1"},' \ # u'{"type": "arc", "id": "2", "begin": "1", "end": "3"},' \ # u'{"type": "node", "id": "3", "identifier": "node2"}]' sctp_client = new_sctp_client() cmd_addr = ScAddr.parse_from_string(request.GET.get(u'cmd', None)) output_addr = ScAddr.parse_from_string(request.GET.get(u'output', None)) # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg = ScAddr.parse_from_string(request.GET.get(u'%d_' % idx, None)) if arg is not None: # check if sc-element exist if sctp_client.check_element(arg): arguments.append(arg) else: return serialize_error(404, "Invalid agument: %s" % arg) first = False idx += 1 if (len(arguments) > 0) and (cmd_addr is not None) and (output_addr is not None): keys = Keynodes(sctp_client) keynode_ui_rrel_commnad = keys[KeynodeSysIdentifiers.ui_rrel_commnad] keynode_ui_rrel_command_arguments = keys[KeynodeSysIdentifiers.ui_rrel_command_arguments] keynode_ui_nrel_command_result = keys[KeynodeSysIdentifiers.ui_nrel_command_result] keynode_ui_user_command_question = keys[KeynodeSysIdentifiers.ui_user_command_question] keynode_ui_command_generate_instance = keys[KeynodeSysIdentifiers.ui_command_generate_instance] keynode_ui_command_initiated = keys[KeynodeSysIdentifiers.ui_command_initiated] keynode_ui_command_finished = keys[KeynodeSysIdentifiers.ui_command_finished] keynode_ui_nrel_command_result = keys[KeynodeSysIdentifiers.ui_nrel_command_result] keynode_ui_user = keys[KeynodeSysIdentifiers.ui_user] keynode_ui_displayed_answer = keys[KeynodeSysIdentifiers.ui_displayed_answer] keynode_nrel_authors = keys[KeynodeSysIdentifiers.nrel_authors] keynode_ui_nrel_user_answer_formats = keys[KeynodeSysIdentifiers.ui_nrel_user_answer_formats] keynode_nrel_translation = keys[KeynodeSysIdentifiers.nrel_translation] keynode_nrel_answer = keys[KeynodeSysIdentifiers.question_nrel_answer] keynode_question_initiated = keys[KeynodeSysIdentifiers.question_initiated] keynode_question = keys[KeynodeSysIdentifiers.question] keynode_system_element = keys[KeynodeSysIdentifiers.system_element] # create command in sc-memory inst_cmd_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) append_to_system_elements(sctp_client, keynode_system_element, inst_cmd_addr) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_command_generate_instance, inst_cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, arc) inst_cmd_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, inst_cmd_addr, cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, inst_cmd_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_rrel_commnad, inst_cmd_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) # create arguments args_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) append_to_system_elements(sctp_client, keynode_system_element, args_addr) args_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, inst_cmd_addr, args_addr) append_to_system_elements(sctp_client, keynode_system_element, args_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_rrel_command_arguments, args_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) idx = 1 for arg in arguments: arg_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, args_addr, arg) append_to_system_elements(sctp_client, keynode_system_element, arg_arc) if arg_arc is None: return serialize_error(404, 'Error while create "create_instance" command') idx_addr = sctp_client.find_element_by_system_identifier(str(u'rrel_%d' % idx)) if idx_addr is None: return serialize_error(404, 'Error while create "create_instance" command') idx += 1 arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, idx_addr, arg_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) wait_time = 0 wait_dt = 0.1 # initialize command arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_command_initiated, inst_cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, arc) cmd_finished = check_command_finished(inst_cmd_addr, keynode_ui_command_finished, sctp_client) while cmd_finished is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > settings.EVENT_WAIT_TIMEOUT: return serialize_error(404, 'Timeout waiting for "create_instance" command finished') cmd_finished = check_command_finished(inst_cmd_addr, keynode_ui_command_finished, sctp_client) # get command result cmd_result = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, inst_cmd_addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_ui_nrel_command_result ) if cmd_result is None: return serialize_error(404, 'Can\'t find "create_instance" command result') cmd_result = cmd_result[0][2] # @todo support all possible commands # try to find question node question = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, keynode_question, ScElementType.sc_type_arc_pos_const_perm, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, cmd_result ) if question is None: return serialize_error(404, 'Can\'t find question node') question = question[0][2] append_to_system_elements(sctp_client, keynode_system_element, question) # create author user_node = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) append_to_system_elements(sctp_client, keynode_system_element, user_node) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_user, user_node) append_to_system_elements(sctp_client, keynode_system_element, arc) author_arc = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const, question, user_node) append_to_system_elements(sctp_client, keynode_system_element, author_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_authors, author_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) # create output formats set output_formats_node = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) append_to_system_elements(sctp_client, keynode_system_element, output_formats_node) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, output_formats_node, output_addr) append_to_system_elements(sctp_client, keynode_system_element, arc) format_arc = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const, question, output_formats_node) append_to_system_elements(sctp_client, keynode_system_element, format_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_nrel_user_answer_formats, format_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) # initiate question arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_question_initiated, question) append_to_system_elements(sctp_client, keynode_system_element, arc) # first of all we need to wait answer to this question #print sctp_client.iterate_elements(SctpIteratorType.SCTP_ITERATOR_3F_A_A, keynode_question_initiated, 0, 0) wait_time = 0 answer = find_answer(question, keynode_nrel_answer, sctp_client) while answer is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > settings.EVENT_WAIT_TIMEOUT: return serialize_error(404, 'Timeout waiting for answer') answer = find_answer(question, keynode_nrel_answer, sctp_client) wait_time = 0 answer_addr = answer[0][2] translation = find_translation(answer_addr, keynode_nrel_translation, sctp_client) while translation is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > settings.EVENT_WAIT_TIMEOUT: return serialize_error(404, 'Timeout waiting for answer translation') translation = find_translation(answer_addr, keynode_nrel_translation, sctp_client) # get output string translation_addr = translation[0][2] result = sctp_client.get_link_content(translation_addr) # mark answer as displayed sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_displayed_answer, answer_addr) return HttpResponse(result, 'application/json')
def get_identifier(request): result = None if request.is_ajax(): lang_code = ScAddr.parse_from_string(request.GET.get(u'language', None)) if lang_code is None: print 'Invalid sc-addr of language' return HttpResponse(None) # get arguments idx = 1 arguments = [] arg = '' while arg is not None: arg = request.GET.get(u'%d_' % idx, None) if arg is not None: arguments.append(arg) idx += 1 sctp_client = new_sctp_client() keys = Keynodes(sctp_client) keynode_ui_nrel_idtf_language_relation = keys[KeynodeSysIdentifiers.ui_nrel_idtf_language_relation] # first of all we need to resolve language relation lang_relation_keynode = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, lang_code, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_ui_nrel_idtf_language_relation ) if lang_relation_keynode is None: print 'Can\'t resolve keynode for language "%s"' % str(lang_code) return HttpResponse(None) lang_relation_keynode = lang_relation_keynode[0][2] result = {} # get requested identifiers for arguments for addr_str in arguments: addr = ScAddr.parse_from_string(addr_str) if addr is None: print 'Can\'t parse sc-addr from argument: %s' % addr_str return serialize_error(404, 'Can\'t parse sc-addr from argument: %s' % addr_str) identifier = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_link, ScElementType.sc_type_arc_pos_const_perm, lang_relation_keynode ) idtf_value = None if identifier is not None: idtf_addr = identifier[0][2] # get identifier value idtf_value = sctp_client.get_link_content(idtf_addr) idtf_value = idtf_value.decode('utf-8') result[addr_str] = idtf_value result = json.dumps(result) return HttpResponse(result, 'application/json')
def post(self): with SctpClientInstance() as sctp_client: question_addr = ScAddr.parse_from_string( self.get_argument(u'question', None)) format_addr = ScAddr.parse_from_string( self.get_argument(u'format', None)) keys = Keynodes(sctp_client) keynode_nrel_answer = keys[ KeynodeSysIdentifiers.question_nrel_answer] keynode_nrel_translation = keys[ KeynodeSysIdentifiers.nrel_translation] keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_system_element = keys[KeynodeSysIdentifiers.system_element] # try to find answer for the question wait_time = 0 wait_dt = 0.1 answer = logic.find_answer(question_addr, keynode_nrel_answer, sctp_client) while answer is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > tornado.options.options.event_wait_timeout: return logic.serialize_error(self, 404, 'Timeout waiting for answer') answer = logic.find_answer(question_addr, keynode_nrel_answer, sctp_client) if answer is None: return logic.serialize_error(self, 404, 'Answer not found') answer_addr = answer[0][2] # try to find translation to specified format result_link_addr = logic.find_translation_with_format( answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) # if link addr not found, then run translation of answer to specified format if result_link_addr is None: trans_cmd_addr = sctp_client.create_node( ScElementType.sc_type_node | ScElementType.sc_type_const) logic.append_to_system_elements(sctp_client, keynode_system_element, trans_cmd_addr) arc_addr = sctp_client.create_arc( ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr, answer_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc( ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_rrel_source_sc_construction], arc_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc( ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr, format_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc( ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_rrel_output_format], arc_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # add into translation command set arc_addr = sctp_client.create_arc( ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_command_translate_from_sc], trans_cmd_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # initialize command arc_addr = sctp_client.create_arc( ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_command_initiated], trans_cmd_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # now we need to wait translation result wait_time = 0 translation = logic.find_translation_with_format( answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) while translation is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > tornado.options.options.event_wait_timeout: return logic.serialize_error( self, 404, 'Timeout waiting for answer translation') translation = logic.find_translation_with_format( answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) if translation is not None: result_link_addr = translation # if result exists, then we need to return it content if result_link_addr is not None: result = json.dumps({"link": result_link_addr.to_int()}) self.set_header("Content-Type", "application/json") self.finish(result)
def idtf_resolve(request): result = None if request.is_ajax(): # get arguments idx = 1 arguments = [] arg = '' while arg is not None: arg = request.POST.get(u'%d_' % idx, None) if arg is not None: arguments.append(arg) idx += 1 sctp_client = new_sctp_client() keys = Keynodes(sctp_client) keynode_nrel_main_idtf = keys[KeynodeSysIdentifiers.nrel_main_idtf] keynode_nrel_system_identifier = keys[KeynodeSysIdentifiers.nrel_system_identifier] sc_session = logic.ScSession(request.user, request.session, sctp_client, keys) used_lang = sc_session.get_used_language() result = {} # get requested identifiers for arguments for addr_str in arguments: addr = ScAddr.parse_from_string(addr_str) if addr is None: print 'Can\'t parse sc-addr from argument: %s' % addr_str return serialize_error(404, 'Can\'t parse sc-addr from argument: %s' % addr_str) found = False identifier = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_link, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_main_idtf ) idtf_value = None if identifier is not None: for res in identifier: idtf_addr = res[2] # check if founded main identifier is for used language langs = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_3F_A_F, used_lang, ScElementType.sc_type_arc_pos_const_perm, idtf_addr ) if langs is not None: # get identifier value idtf_value = sctp_client.get_link_content(idtf_addr) idtf_value = idtf_value.decode('utf-8') found = True result[addr_str] = idtf_value # if identifier not found, then get system identifier if not found: identifier = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_link, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_system_identifier ) if identifier is not None: idtf_value = sctp_client.get_link_content(identifier[0][2]) idtf_value = idtf_value.decode('utf-8') result[addr_str] = idtf_value result = json.dumps(result) return HttpResponse(result, 'application/json')
def cmd_do(request): result = '[]' if request.is_ajax(): sctp_client = new_sctp_client() cmd_addr = ScAddr.parse_from_string(request.POST.get(u'cmd', None)) # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg = ScAddr.parse_from_string(request.POST.get(u'%d_' % idx, None)) if arg is not None: # check if sc-element exist if sctp_client.check_element(arg): arguments.append(arg) else: return serialize_error(404, "Invalid argument: %s" % arg) first = False idx += 1 if (len(arguments) > 0) and (cmd_addr is not None): keys = Keynodes(sctp_client) keynode_ui_rrel_commnad = keys[KeynodeSysIdentifiers.ui_rrel_commnad] keynode_ui_rrel_command_arguments = keys[KeynodeSysIdentifiers.ui_rrel_command_arguments] keynode_ui_nrel_command_result = keys[KeynodeSysIdentifiers.ui_nrel_command_result] keynode_ui_user_command_question = keys[KeynodeSysIdentifiers.ui_user_command_question] keynode_ui_command_generate_instance = keys[KeynodeSysIdentifiers.ui_command_generate_instance] keynode_ui_command_initiated = keys[KeynodeSysIdentifiers.ui_command_initiated] keynode_ui_command_finished = keys[KeynodeSysIdentifiers.ui_command_finished] keynode_ui_nrel_command_result = keys[KeynodeSysIdentifiers.ui_nrel_command_result] keynode_ui_user = keys[KeynodeSysIdentifiers.ui_user] #keynode_ui_displayed_answer = keys[KeynodeSysIdentifiers.ui_displayed_answer] keynode_nrel_authors = keys[KeynodeSysIdentifiers.nrel_authors] #keynode_ui_nrel_user_answer_formats = keys[KeynodeSysIdentifiers.ui_nrel_user_answer_formats] #keynode_nrel_translation = keys[KeynodeSysIdentifiers.nrel_translation] #keynode_nrel_answer = keys[KeynodeSysIdentifiers.question_nrel_answer] keynode_question_initiated = keys[KeynodeSysIdentifiers.question_initiated] keynode_question = keys[KeynodeSysIdentifiers.question] keynode_system_element = keys[KeynodeSysIdentifiers.system_element] # create command in sc-memory inst_cmd_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) append_to_system_elements(sctp_client, keynode_system_element, inst_cmd_addr) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_command_generate_instance, inst_cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, arc) inst_cmd_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, inst_cmd_addr, cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, inst_cmd_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_rrel_commnad, inst_cmd_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) # create arguments args_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) append_to_system_elements(sctp_client, keynode_system_element, args_addr) args_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, inst_cmd_addr, args_addr) append_to_system_elements(sctp_client, keynode_system_element, args_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_rrel_command_arguments, args_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) idx = 1 for arg in arguments: arg_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, args_addr, arg) append_to_system_elements(sctp_client, keynode_system_element, arg_arc) if arg_arc is None: return serialize_error(404, 'Error while create "create_instance" command') idx_addr = sctp_client.find_element_by_system_identifier(str(u'rrel_%d' % idx)) if idx_addr is None: return serialize_error(404, 'Error while create "create_instance" command') idx += 1 arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, idx_addr, arg_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) wait_time = 0 wait_dt = 0.1 # initialize command arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_command_initiated, inst_cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, arc) cmd_finished = check_command_finished(inst_cmd_addr, keynode_ui_command_finished, sctp_client) while cmd_finished is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > settings.EVENT_WAIT_TIMEOUT: return serialize_error(404, 'Timeout waiting for "create_instance" command finished') cmd_finished = check_command_finished(inst_cmd_addr, keynode_ui_command_finished, sctp_client) # get command result cmd_result = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, inst_cmd_addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_ui_nrel_command_result ) if cmd_result is None: return serialize_error(404, 'Can\'t find "create_instance" command result') cmd_result = cmd_result[0][2] # @todo support all possible commands # try to find question node question = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, keynode_question, ScElementType.sc_type_arc_pos_const_perm, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, cmd_result ) if question is None: return serialize_error(404, "Can't find question node") question = question[0][2] append_to_system_elements(sctp_client, keynode_system_element, question) # create author sc_session = logic.ScSession(request.user, request.session, sctp_client, keys) user_node = sc_session.get_sc_addr() if not user_node: return serialize_error(404, "Can't resolve user node") arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_user, user_node) append_to_system_elements(sctp_client, keynode_system_element, arc) author_arc = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const, question, user_node) append_to_system_elements(sctp_client, keynode_system_element, author_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_authors, author_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) # create output formats set '''output_formats_node = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) append_to_system_elements(sctp_client, keynode_system_element, output_formats_node) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, output_formats_node, output_addr) append_to_system_elements(sctp_client, keynode_system_element, arc) format_arc = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const, question, output_formats_node) append_to_system_elements(sctp_client, keynode_system_element, format_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_nrel_user_answer_formats, format_arc) append_to_system_elements(sctp_client, keynode_system_element, arc)''' # initiate question arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_question_initiated, question) append_to_system_elements(sctp_client, keynode_system_element, arc) # first of all we need to wait answer to this question #print sctp_client.iterate_elements(SctpIteratorType.SCTP_ITERATOR_3F_A_A, keynode_question_initiated, 0, 0) result = { 'question': question.to_id() } result = json.dumps(result) return HttpResponse(result, 'application/json')
def question_answer_translate(request): if request.is_ajax(): sctp_client = new_sctp_client() question_addr = ScAddr.parse_from_string(request.POST.get(u'question', None)) format_addr = ScAddr.parse_from_string(request.POST.get(u'format', None)) keys = Keynodes(sctp_client) keynode_nrel_answer = keys[KeynodeSysIdentifiers.question_nrel_answer] keynode_nrel_translation = keys[KeynodeSysIdentifiers.nrel_translation] keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_system_element = keys[KeynodeSysIdentifiers.system_element] # try to find answer for the question wait_time = 0 wait_dt = 0.1 answer = find_answer(question_addr, keynode_nrel_answer, sctp_client) while answer is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > settings.EVENT_WAIT_TIMEOUT: return serialize_error(404, 'Timeout waiting for answer') answer = find_answer(question_addr, keynode_nrel_answer, sctp_client) if answer is None: return serialize_error(404, 'Answer not found') answer_addr = answer[0][2] result_link_addr = None # try to find translation to specified format result_link_addr = find_translation_with_format(answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) # if link addr not found, then run translation of answer to specified format if result_link_addr is None: trans_cmd_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) append_to_system_elements(sctp_client, keynode_system_element, trans_cmd_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr, answer_addr) append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_rrel_source_sc_construction], arc_addr) append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr, format_addr) append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_rrel_output_format], arc_addr) append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # add into translation command set arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_command_translate_from_sc], trans_cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # initialize command arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_command_initiated], trans_cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # now we need to wait translation result wait_time = 0 translation = find_translation_with_format(answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) while translation is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > settings.EVENT_WAIT_TIMEOUT: return serialize_error(404, 'Timeout waiting for answer translation') translation = find_translation_with_format(answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) if translation is not None: result_link_addr = translation # if result exists, then we need to return it content if result_link_addr is not None: result = json.dumps({"link": result_link_addr.to_id()}) return HttpResponse(result, 'application/json') return serialize_error(404, "Can't make translation")
def post(self): with SctpClientInstance() as sctp_client: question_addr = ScAddr.parse_from_string(self.get_argument(u'question', None)) format_addr = ScAddr.parse_from_string(self.get_argument(u'format', None)) keys = Keynodes(sctp_client) keynode_nrel_answer = keys[KeynodeSysIdentifiers.question_nrel_answer] keynode_nrel_translation = keys[KeynodeSysIdentifiers.nrel_translation] keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_system_element = keys[KeynodeSysIdentifiers.system_element] # try to find answer for the question wait_time = 0 wait_dt = 0.1 answer = logic.find_answer(question_addr, keynode_nrel_answer, sctp_client) while answer is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > tornado.options.options.event_wait_timeout: return logic.serialize_error(self, 404, 'Timeout waiting for answer') answer = logic.find_answer(question_addr, keynode_nrel_answer, sctp_client) if answer is None: return logic.serialize_error(self, 404, 'Answer not found') answer_addr = answer[0][2] # try to find translation to specified format result_link_addr = logic.find_translation_with_format(answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) # if link addr not found, then run translation of answer to specified format if result_link_addr is None: trans_cmd_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) logic.append_to_system_elements(sctp_client, keynode_system_element, trans_cmd_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr, answer_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_rrel_source_sc_construction], arc_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr, format_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_rrel_output_format], arc_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # add into translation command set arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_command_translate_from_sc], trans_cmd_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # initialize command arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_command_initiated], trans_cmd_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # now we need to wait translation result wait_time = 0 translation = logic.find_translation_with_format(answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) while translation is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > tornado.options.options.event_wait_timeout: return logic.serialize_error(self, 404, 'Timeout waiting for answer translation') translation = logic.find_translation_with_format(answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) if translation is not None: result_link_addr = translation # if result exists, then we need to return it content if result_link_addr is not None: result = json.dumps({"link": result_link_addr.to_int()}) self.set_header("Content-Type", "application/json") self.finish(result)
def post(self): result = '[]' with SctpClientInstance() as sctp_client: cmd_addr = ScAddr.parse_from_string(self.get_argument(u'cmd', None)) # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg = ScAddr.parse_from_string(self.get_argument(u'%d_' % idx, None)) if arg is not None: # check if sc-element exist if sctp_client.check_element(arg): arguments.append(arg) else: return serialize_error(404, "Invalid argument: %s" % arg) first = False idx += 1 if (len(arguments) > 0) and (cmd_addr is not None): keys = Keynodes(sctp_client) keynode_ui_rrel_commnad = keys[KeynodeSysIdentifiers.ui_rrel_commnad] keynode_ui_rrel_command_arguments = keys[KeynodeSysIdentifiers.ui_rrel_command_arguments] keynode_ui_nrel_command_result = keys[KeynodeSysIdentifiers.ui_nrel_command_result] keynode_ui_command_generate_instance = keys[KeynodeSysIdentifiers.ui_command_generate_instance] keynode_ui_command_initiated = keys[KeynodeSysIdentifiers.ui_command_initiated] keynode_ui_command_finished = keys[KeynodeSysIdentifiers.ui_command_finished] keynode_ui_nrel_command_result = keys[KeynodeSysIdentifiers.ui_nrel_command_result] keynode_ui_user = keys[KeynodeSysIdentifiers.ui_user] keynode_nrel_authors = keys[KeynodeSysIdentifiers.nrel_authors] keynode_question_initiated = keys[KeynodeSysIdentifiers.question_initiated] keynode_question = keys[KeynodeSysIdentifiers.question] keynode_system_element = keys[KeynodeSysIdentifiers.system_element] keynode_nrel_ui_nrel_command_lang_template = keys[KeynodeSysIdentifiers.nrel_ui_nrel_command_lang_template] keynode_languages = keys[KeynodeSysIdentifiers.languages] keynode_nrel_main_idtf = keys[KeynodeSysIdentifiers.nrel_main_idtf] # create command in sc-memory inst_cmd_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) logic.append_to_system_elements(sctp_client, keynode_system_element, inst_cmd_addr) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_command_generate_instance, inst_cmd_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) inst_cmd_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, inst_cmd_addr, cmd_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, inst_cmd_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_rrel_commnad, inst_cmd_arc) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) # create arguments args_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) logic.append_to_system_elements(sctp_client, keynode_system_element, args_addr) args_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, inst_cmd_addr, args_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, args_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_rrel_command_arguments, args_arc) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) idx = 1 for arg in arguments: arg_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, args_addr, arg) logic.append_to_system_elements(sctp_client, keynode_system_element, arg_arc) if arg_arc is None: return serialize_error(self, 404, 'Error while create "create_instance" command') idx_addr = sctp_client.find_element_by_system_identifier(str(u'rrel_%d' % idx)) if idx_addr is None: return serialize_error(self, 404, 'Error while create "create_instance" command') idx += 1 arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, idx_addr, arg_arc) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) wait_time = 0 wait_dt = 0.1 # initialize command arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_command_initiated, inst_cmd_addr) cmd_finished = logic.check_command_finished(inst_cmd_addr, keynode_ui_command_finished, sctp_client) while cmd_finished is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > tornado.options.options.event_wait_timeout: return serialize_error(self, 404, 'Timeout waiting for "create_instance" command finished') cmd_finished = logic.check_command_finished(inst_cmd_addr, keynode_ui_command_finished, sctp_client) # get command result cmd_result = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, inst_cmd_addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_ui_nrel_command_result ) if cmd_result is None: return serialize_error(self, 404, 'Can\'t find "create_instance" command result') cmd_result = cmd_result[0][2] # @todo support all possible commands # try to find question node question = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, keynode_question, ScElementType.sc_type_arc_pos_const_perm, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, cmd_result ) if question is None: return serialize_error(self, 404, "Can't find question node") question = question[0][2] logic.append_to_system_elements(sctp_client, keynode_system_element, question) # generate main identifiers langs = logic.get_languages_list(keynode_languages, sctp_client) if langs: templates = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, cmd_addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_link, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_ui_nrel_command_lang_template ) if templates: generated = {} identifiers = {} # get identifiers for l in langs: identifiers[str(l)] = {} for a in arguments: idtf_value = logic.get_identifier_translated(a, l, keys, sctp_client) if idtf_value: identifiers[str(l)][str(a)] = idtf_value for t in templates: input_arcs = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_3A_A_F, ScElementType.sc_type_node | ScElementType.sc_type_const | ScElementType.sc_type_node_class, ScElementType.sc_type_arc_pos_const_perm, t[2]) if input_arcs: for arc in input_arcs: for l in langs: if not generated.has_key(str(l)) and arc[0] == l: lang_idtfs = identifiers[str(l)] # get content of link data = sctp_client.get_link_content(t[2]).decode('utf-8') if data: for idx in xrange(len(arguments)): value = arguments[idx].to_id() if lang_idtfs.has_key(str(arguments[idx])): value = lang_idtfs[str(arguments[idx])] data = data.replace(u'$ui_arg_%d' % (idx + 1), value) # generate identifier idtf_link = sctp_client.create_link() sctp_client.set_link_content(idtf_link, str(data.encode('utf-8'))) sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, l, idtf_link) bin_arc = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const, question, idtf_link) sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_main_idtf, bin_arc) generated[str(l)] = True # create author sc_session = logic.ScSession(self, sctp_client, keys) user_node = sc_session.get_sc_addr() if not user_node: return serialize_error(self, 404, "Can't resolve user node") arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_user, user_node) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) author_arc = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const, question, user_node) logic.append_to_system_elements(sctp_client, keynode_system_element, author_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_authors, author_arc) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) # initiate question arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_question_initiated, question) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) # first of all we need to wait answer to this question #print sctp_client.iterate_elements(SctpIteratorType.SCTP_ITERATOR_3F_A_A, keynode_question_initiated, 0, 0) result = { 'question': question.to_id() } self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))