def get(self): result = '{}' with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) # get user sc-addr sc_session = logic.ScSession(self, sctp_client, keys) user_addr = sc_session.get_sc_addr() if sc_session.email: is_authenticated = True else: is_authenticated = False roles = [] if is_authenticated: user_kb_node = sc_session.get_user_kb_node_by_email() if user_kb_node is not None: roles = self.get_user_roles(sctp_client, user_kb_node, keys) result = { 'sc_addr': user_addr.to_int(), 'is_authenticated': is_authenticated, 'current_lang': sc_session.get_used_language().to_int(), 'default_ext_lang': sc_session.get_default_ext_lang().to_int(), 'email': sc_session.email, 'roles': roles } self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def register_user(self, email, user_name): with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) links = sctp_client.find_links_with_content(str(email)) if links and len(links) == 1: user = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_F, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, links[0], ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.nrel_email] ) if user and user[0] and user[0][0]: results = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5_F_A_F_A_F, keys[KeynodeSysIdentifiers.Myself], ScElementType.sc_type_arc_common | ScElementType.sc_type_const, user[0][0], ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.nrel_registered_user] ) if results is None: self.gen_registred_user_relation(sctp_client, keys, user[0][0]) else: user_node = self.create_ui_user_node_at_kb(sctp_client, keys, email, user_name) self.gen_registred_user_relation(sctp_client, keys, user_node) else: user_node = self.create_ui_user_node_at_kb(sctp_client, keys, email, user_name) self.gen_registred_user_relation(sctp_client, keys, user_node)
def _loggedin(self, user): email = user['email'] if len(email) == 0: return database = db.DataBase() u = database.get_user_by_email(email) key = None if u: key = database.create_user_key() u.key = key database.update_user(u) else: role = 0 supers = tornado.options.options.super_emails if supers and (email in supers): r = database.get_role_by_name('super') if r: role = r.id with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) key = database.add_user(name=user['name'], email=email, avatar=user['picture'], role=role) self.set_secure_cookie(self.cookie_user_key, key, 1)
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 logout_user_from_kb(self): with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) links = sctp_client.find_links_with_content(str(sc_session.email)) if links and len(links) == 1: user = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_F, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, links[0], ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.nrel_email] ) results = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5_F_A_F_A_F, keys[KeynodeSysIdentifiers.Myself], ScElementType.sc_type_arc_common | ScElementType.sc_type_const, user[0][0], ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.nrel_authorised_user] ) if results and results[0] and results[0][1]: sctp_client.erase_element(results[0][1])
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 get(self): with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) langs = logic.get_languages_list(keys[KeynodeSysIdentifiers.languages], sctp_client) self.set_header("Content-Type", "application/json") self.finish(json.dumps(langs))
def post(self): with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) ai = apiai.ApiAI(tornado.options.options.apiai_client_access_token, tornado.options.options.apiai_subscription_key) request = ai.text_request() query = self.get_argument('query', u'') request.query = query.encode('utf-8') # TODO: make universal language selection keynode_lang_ru = keys[KeynodeSysIdentifiers.lang_ru] used_lang = sc_session.get_used_language() if (used_lang == keynode_lang_ru): request.lang = 'ru' else: request.lang = 'en' response = request.getresponse() result = '[]' apiRes = json.loads(response.read()) actionResult = apiRes['result'] cmd_addr = sctp_client.find_element_by_system_identifier( str(actionResult['action'])) if cmd_addr: arguments = [] parameters = actionResult['parameters'] idx = 1 found = True while found: key = 'ui_arg_%d' % idx idx = idx + 1 found = False try: arg_addr = logic.get_by_identifier_translated( used_lang, keys, sctp_client, str(parameters[key].encode('utf-8'))) if arg_addr is not None: arguments.append(arg_addr) found = True except KeyError: break 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): 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 get(self): result = '{}' with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) keynode_ui_main_menu = keys[KeynodeSysIdentifiers.ui_main_menu] keynode_ui_external_languages = keys[ KeynodeSysIdentifiers.ui_external_languages] keynode_languages = keys[KeynodeSysIdentifiers.languages] # try to find main menu node cmds = logic.parse_menu_command(keynode_ui_main_menu, sctp_client, keys) if cmds is None: cmds = {} # try to find available output languages res_out_langs = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_3F_A_A, keynode_ui_external_languages, ScElementType.sc_type_arc_pos_const_perm, ScElementType.sc_type_node | ScElementType.sc_type_const) out_langs = [] if (res_out_langs is not None): for items in res_out_langs: out_langs.append(items[2].to_int()) # try to find available output natural languages langs = logic.get_languages_list(keynode_languages, sctp_client) langs_str = [] for l in langs: langs_str.append(l.to_int()) # get user sc-addr sc_session = logic.ScSession(self, sctp_client, keys) user_addr = sc_session.get_sc_addr() result = { 'menu_commands': cmds, 'languages': langs_str, 'external_languages': out_langs, 'user': { 'sc_addr': user_addr.to_int(), 'is_authenticated': False, 'current_lang': sc_session.get_used_language().to_int(), 'default_ext_lang': sc_session.get_default_ext_lang().to_int() } } self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def get(self): with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) keynode_ui_main_menu = keys[KeynodeSysIdentifiers.ui_main_menu] keynode_ui_external_languages = keys[KeynodeSysIdentifiers.ui_external_languages] keynode_languages = keys[KeynodeSysIdentifiers.languages] # try to find main menu node cmds = [] logic.find_atomic_commands(keynode_ui_main_menu, sctp_client, keys, cmds) self.set_header("Content-Type", "application/json") self.finish(json.dumps(cmds))
def get(self): result = '{}' with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) # get user sc-addr sc_session = logic.ScSession(self, sctp_client, keys) user_addr = sc_session.get_sc_addr() result = { 'sc_addr': user_addr.to_int(), 'is_authenticated': False, 'current_lang': sc_session.get_used_language().to_int(), 'default_ext_lang': sc_session.get_default_ext_lang().to_int() } self.set_header("Content-Type", "application/json") self.finish(json.dumps(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 authorise_user(self, email): with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) links = sctp_client.find_links_with_content(str(email)) if links and len(links) == 1: user = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_F, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, links[0], ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.nrel_email] ) bin_arc_authorised = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const, keys[KeynodeSysIdentifiers.Myself], user[0][0]) sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.nrel_authorised_user], bin_arc_authorised)
def post(self): with SctpClientInstance() as 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_int()] = format[0][2].to_int() else: result[arg.to_int()] = keynode_format_txt.to_int() 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 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: res = {} for idtf in arguments: addr = sctp_client.find_element_by_system_identifier(str(idtf)) if addr is not None: res[idtf] = addr.to_int() self.set_header("Content-Type", "application/json") self.finish(json.dumps(res))
def get(self): result = None # get arguments substr = self.get_argument('substr', None) # connect to redis an try to find identifiers r = redis.StrictRedis(host=tornado.options.options.redis_host, port=tornado.options.options.redis_port, db=tornado.options.options.redis_db_idtf) result = {} sys = [] main = [] common = [] max_n = tornado.options.options.idtf_serach_limit def appendSorted(array, data): if len(array) > 0: idx = 0 inserted = False for idx in xrange(len(array)): if len(array[idx][1]) > len(data[1]): array.insert(idx, data) inserted = True break idx = idx + 1 if not inserted and len(array) < max_n: array.append(data) if (len(array) > max_n): array.pop() else: array.append(data) # first of all need to find system identifiers cursor = 0 while True: reply = r.scan(cursor, u"idtf:*%s*" % substr, 1000) if not reply or len(reply) == 0: break cursor = int(reply[0]) for idtf in reply[1]: if len(sys) == max_n and len(main) == max_n and len( common) == max_n: break rep = r.get(idtf) utf = idtf.decode('utf-8') addr = ScAddr.parse_binary(rep) if utf.startswith(u"idtf:sys:") and len(sys) < max_n: appendSorted(sys, [addr.to_int(), utf[9:]]) elif utf.startswith(u"idtf:main:") and len(main) < max_n: appendSorted(main, [addr.to_int(), utf[10:]]) elif utf.startswith(u"idtf:common:") and len(common) < max_n: appendSorted(common, [addr.to_int(), utf[12:]]) if cursor == 0: break with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) keynode_nrel_main_idtf = keys[KeynodeSysIdentifiers.nrel_main_idtf] keynode_nrel_system_identifier = keys[ KeynodeSysIdentifiers.nrel_system_identifier] keynode_nrel_idtf = keys[KeynodeSysIdentifiers.nrel_idtf] result['sys'] = sys result['main'] = main result['common'] = common self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
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))