示例#1
0
文件: api.py 项目: SABilida/sc-web
    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 = self.get_argument(arg_str, None)
            if arg is not None:
                arguments.append(arg)
            first = False
            idx += 1
            
        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

        sctp_client.shutdown()
        self.set_header("Content-Type", "application/json")
        self.finish(json.dumps(res))
示例#2
0
文件: views.py 项目: bakhmetow/repo
def sc_addrs(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

        res = {}
        for idtf in arguments:
            addr = sctp_client.find_element_by_system_identifier(str(idtf))
            if addr is not None:
                res[idtf] = addr.to_id()

        result = json.dumps(res)

    return HttpResponse(result, 'application/json')
示例#3
0
文件: views.py 项目: Gr1N/sc-web
def get_statistics(request):
    """Returns list of statistics data
    """

    result = '[]'
    if request.is_ajax():
        # parse arguments
        try:
            fromArg = int(request.GET.get('from', None))
            toArg = int(request.GET.get('to', None))
        except ValueError:
            return serialize_error(404, 'Invalid arguments')
        
        sctp_client = new_sctp_client()
        stat_data = sctp_client.get_statistics(fromArg, toArg)

        data = []  # ['Nodes', 'Arcs', 'Links', 'Live nodes', 'Live arcs', 'Live links', 'Empty', 'Connections', 'Commands', 'Command errors']
        for item in stat_data:
            data.append([
                item.time,
                item.nodeCount,
                item.arcCount,
                item.linksCount,
                item.liveNodeCount,
                item.liveArcCount,
                item.liveLinkCount,
                item.emptyCount,
                item.connectionsCount,
                item.commandsCount,
                item.commandErrorsCount,
            ])

        result = json.dumps(data)

    return HttpResponse(result, 'application/json')
示例#4
0
文件: api.py 项目: DmitryKus/sc-web
    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 = self.get_argument(arg_str, None)
            if arg is not None:
                arguments.append(arg)
            first = False
            idx += 1

        res = {}
        for idtf in arguments:
            addr = sctp_client.find_element_by_system_identifier(str(idtf))
            if addr is not None:
                res[idtf] = addr.to_id()

        sctp_client.shutdown()
        self.set_header("Content-Type", "application/json")
        self.finish(json.dumps(res))
示例#5
0
文件: api.py 项目: SABilida/sc-web
    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 = self.get_argument(arg_str, None)
            if arg is not None:
                arguments.append(arg)
            first = False
            idx += 1

        res = {}
        for idtf in arguments:
            addr = sctp_client.find_element_by_system_identifier(str(idtf))
            if addr is not None:
                res[idtf] = addr.to_id()

        sctp_client.shutdown()
        self.set_header("Content-Type", "application/json")
        self.finish(json.dumps(res))
示例#6
0
文件: api.py 项目: DmitryKus/sc-web
    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 = self.get_argument(arg_str, None)
            if arg is not None:
                arguments.append(arg)
            first = False
            idx += 1
            
        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

        sctp_client.shutdown()
        self.set_header("Content-Type", "application/json")
        self.finish(json.dumps(res))
示例#7
0
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')
示例#8
0
文件: api.py 项目: DmitryKus/sc-web
 def get(self):
     
     sctp_client = new_sctp_client()
     keys = Keynodes(sctp_client)
     
     langs = logic.get_languages_list(keys[KeynodeSysIdentifiers.languages], sctp_client)
     
     sctp_client.shutdown()
     self.set_header("Content-Type", "application/json")
     self.finish(json.dumps(langs))
示例#9
0
文件: api.py 项目: SABilida/sc-web
 def get(self):
     
     sctp_client = new_sctp_client()
     keys = Keynodes(sctp_client)
     
     langs = logic.get_languages_list(keys[KeynodeSysIdentifiers.languages], sctp_client)
     
     sctp_client.shutdown()
     self.set_header("Content-Type", "application/json")
     self.finish(json.dumps(langs))
示例#10
0
文件: api.py 项目: DmitryKus/sc-web
    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
        
        # first of all need to find system identifiers
        cursor = 0
        while True:
            reply = r.scan(cursor, u"idtf:*%s*" % substr, 200)
            if not reply or len(reply) == 0:
                break
            cursor = int(reply[0])
            if cursor == 0:
                break
            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:
                    sys.append([addr.to_id(), utf[9:]])
                elif utf.startswith(u"idtf:main:") and len(main) < max_n:
                    main.append([addr.to_id(), utf[10:]])
                elif utf.startswith(u"idtf:common:") and len(common) < max_n:
                    common.append([addr.to_id(), utf[12:]])
                    

        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]
        keynode_nrel_idtf = keys[KeynodeSysIdentifiers.nrel_idtf]
                    
        result[keynode_nrel_system_identifier.to_id()] = sys
        result[keynode_nrel_main_idtf.to_id()] = main
        result[keynode_nrel_idtf.to_id()] = common
        
        sctp_client.shutdown()
        self.set_header("Content-Type", "application/json")
        self.finish(json.dumps(result))
示例#11
0
文件: api.py 项目: SABilida/sc-web
    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
        
        # first of all need to find system identifiers
        cursor = 0
        while True:
            reply = r.scan(cursor, u"idtf:*%s*" % substr, 200)
            if not reply or len(reply) == 0:
                break
            cursor = int(reply[0])
            if cursor == 0:
                break
            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:
                    sys.append([addr.to_id(), utf[9:]])
                elif utf.startswith(u"idtf:main:") and len(main) < max_n:
                    main.append([addr.to_id(), utf[10:]])
                elif utf.startswith(u"idtf:common:") and len(common) < max_n:
                    common.append([addr.to_id(), utf[12:]])
                    

        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]
        keynode_nrel_idtf = keys[KeynodeSysIdentifiers.nrel_idtf]
                    
        result[keynode_nrel_system_identifier.to_id()] = sys
        result[keynode_nrel_main_idtf.to_id()] = main
        result[keynode_nrel_idtf.to_id()] = common
        
        sctp_client.shutdown()
        self.set_header("Content-Type", "application/json")
        self.finish(json.dumps(result))
示例#12
0
文件: views.py 项目: bakhmetow/repo
def get_languages(request):
    result = []
    if request.is_ajax():
        
        sctp_client = new_sctp_client()
        keys = Keynodes(sctp_client)
        
        langs = get_languages_list(keys[KeynodeSysIdentifiers.languages], sctp_client)
        
        result = json.dumps(langs)
        
    return HttpResponse(result, 'application/json')
示例#13
0
文件: api.py 项目: DmitryKus/sc-web
 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()
示例#14
0
文件: api.py 项目: SABilida/sc-web
 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()
示例#15
0
def init(request):
    result = '{}'
    if request.is_ajax():

        sctp_client = new_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 = parse_menu_command(keynode_ui_main_menu, sctp_client, keys)
        if cmds is None:
            print 'There are no main menu in knowledge base'
            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_id())

        # try to find available output natural languages
        langs = get_languages_list(keynode_languages, sctp_client)
        langs_str = []
        for l in langs:
            langs_str.append(l.to_id())
        
        # get user sc-addr
        sc_session = logic.ScSession(request.user, request.session, 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_id(),
                            'is_authenticated': request.user.is_authenticated(),
                            'current_lang': sc_session.get_used_language().to_id(),
                            'default_ext_lang': sc_session.get_default_ext_lang().to_id()
                           }
        }

        result = json.dumps(result)

    return HttpResponse(result, 'application/json')
示例#16
0
文件: api.py 项目: SABilida/sc-web
    def get(self):
        result = '{}'
    
        sctp_client = new_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_id())

        # 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_id())
        
        # 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_id(),
                            'is_authenticated': False,
                            'current_lang': sc_session.get_used_language().to_id(),
                            'default_ext_lang': sc_session.get_default_ext_lang().to_id()
                           }
        }
    
        sctp_client.shutdown()
        self.set_header("Content-Type", "application/json")
        self.finish(json.dumps(result))
示例#17
0
def idtf_find(request):
    result = None
    if request.is_ajax():
        # get arguments
        substr = request.GET.get('substr', None)
        
        # connect to redis an try to find identifiers
        r = redis.StrictRedis(host = settings.REDIS_HOST, port = settings.REDIS_PORT, db = settings.REDIS_DB)
        result = {}
        sys = []
        main = []
        common = []
        
        # first of all need to find system identifiers
        cursor = 0
        while True:
            reply = r.scan(cursor, u"idtf:*%s*" % substr, 200)
            if not reply or len(reply) == 0:
                break
            cursor = int(reply[0])
            if cursor == 0:
                break
            for idtf in reply[1]:
                if len(sys) == settings.IDTF_SEARCH_LIMIT and len(main) == settings.IDTF_SEARCH_LIMIT and len(common) == settings.IDTF_SEARCH_LIMIT:
                    break
                
                rep = r.get(idtf)
                utf = idtf.decode('utf-8')
                addr = ScAddr.parse_binary(rep)
                if utf.startswith(u"idtf:sys:") and len(sys) < settings.IDTF_SEARCH_LIMIT:
                    sys.append([addr.to_id(), utf[9:]])
                elif utf.startswith(u"idtf:main:") and len(main) < settings.IDTF_SEARCH_LIMIT:
                    main.append([addr.to_id(), utf[10:]])   
                elif utf.startswith(u"idtf:common:") and len(common) < settings.IDTF_SEARCH_LIMIT:
                    common.append([addr.to_id(), utf[12:]])          
                    

        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]
        keynode_nrel_idtf = keys[KeynodeSysIdentifiers.nrel_idtf]
                    
        result[keynode_nrel_system_identifier.to_id()] = sys
        result[keynode_nrel_main_idtf.to_id()] = main
        result[keynode_nrel_idtf.to_id()] = common
        
        result = json.dumps(result)

    return HttpResponse(result, 'application/json')
示例#18
0
文件: api.py 项目: DmitryKus/sc-web
    def get(self):
        result = '{}'
    
        sctp_client = new_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_id())

        # 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_id())
        
        # 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_id(),
                            'is_authenticated': False,
                            'current_lang': sc_session.get_used_language().to_id(),
                            'default_ext_lang': sc_session.get_default_ext_lang().to_id()
                           }
        }
    
        sctp_client.shutdown()
        self.set_header("Content-Type", "application/json")
        self.finish(json.dumps(result))
示例#19
0
文件: views.py 项目: bakhmetow/repo
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')
示例#20
0
文件: views.py 项目: Gr1N/sc-web
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')
示例#21
0
文件: views.py 项目: bakhmetow/repo
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')
示例#22
0
文件: api.py 项目: DmitryKus/sc-web
 def get(self):
     result = '{}'
 
     sctp_client = new_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_id(),
                 'is_authenticated': False,
                 'current_lang': sc_session.get_used_language().to_id(),
                 'default_ext_lang': sc_session.get_default_ext_lang().to_id()
     }
 
     sctp_client.shutdown()
     self.set_header("Content-Type", "application/json")
     self.finish(json.dumps(result))
示例#23
0
文件: views.py 项目: Gr1N/sc-web
def get_menu_commands(request):
    result = '[]'
    if request.is_ajax():

        sctp_client = new_sctp_client()

        keys = Keynodes(sctp_client)

        keynode_ui_main_menu = keys[KeynodeSysIdentifiers.ui_main_menu]

        # try to find main menu node
        result = parse_menu_command(keynode_ui_main_menu, sctp_client, keys)
        if result is None:
            print 'There are no main menu in knowledge base'
            result = '[]'
        else:
            result = json.dumps(result)

    return HttpResponse(result, 'application/json')
示例#24
0
文件: api.py 项目: SABilida/sc-web
 def get(self):
     result = '{}'
 
     sctp_client = new_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_id(),
                 'is_authenticated': False,
                 'current_lang': sc_session.get_used_language().to_id(),
                 'default_ext_lang': sc_session.get_default_ext_lang().to_id()
     }
 
     sctp_client.shutdown()
     self.set_header("Content-Type", "application/json")
     self.finish(json.dumps(result))
示例#25
0
文件: views.py 项目: bakhmetow/repo
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')
示例#26
0
文件: api.py 项目: DmitryKus/sc-web
    def get(self):

        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(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')
    
        sctp_client.shutdown()
        self.set_header("Content-Type", logic.get_link_mime(addr, keynode_nrel_format, keynode_nrel_mimetype, sctp_client))
        self.finish(result)
示例#27
0
文件: api.py 项目: SABilida/sc-web
    def get(self):

        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(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')
    
        sctp_client.shutdown()
        self.set_header("Content-Type", logic.get_link_mime(addr, keynode_nrel_format, keynode_nrel_mimetype, sctp_client))
        self.finish(result)
示例#28
0
文件: api.py 项目: DmitryKus/sc-web
    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))
示例#29
0
文件: api.py 项目: SABilida/sc-web
    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))
示例#30
0
文件: api.py 项目: SABilida/sc-web
    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))
示例#31
0
文件: api.py 项目: DmitryKus/sc-web
    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))
示例#32
0
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')
示例#33
0
文件: views.py 项目: Gr1N/sc-web
def available_idtf_langs(request):
    """Returns list of available identifier languages
    """
    result = '[]'
    if request.is_ajax():
        sctp_client = new_sctp_client()

        keys = Keynodes(sctp_client)

        keynode_ui_idtf_languages = keys[KeynodeSysIdentifiers.ui_idtf_languages]
        res = sctp_client.iterate_elements(
            SctpIteratorType.SCTP_ITERATOR_3F_A_A,
            keynode_ui_idtf_languages,
            ScElementType.sc_type_arc_pos_const_perm,
            ScElementType.sc_type_node | ScElementType.sc_type_const
        )
        if (res is not None):
            result = []
            for items in res:
                result.append(items[2].to_id())

            result = json.dumps(result)

    return HttpResponse(result, 'application/json')
示例#34
0
文件: views.py 项目: bakhmetow/repo
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')
示例#35
0
文件: views.py 项目: bakhmetow/repo
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')
示例#36
0
文件: views.py 项目: bakhmetow/repo
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")
示例#37
0
文件: views.py 项目: Gr1N/sc-web
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')
示例#38
0
文件: api.py 项目: SABilida/sc-web
    def post(self):
        result = '[]'
        sctp_client = new_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)
            logic.append_to_system_elements(sctp_client, keynode_system_element, arc)

            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() }
            
        sctp_client.shutdown()
        self.set_header("Content-Type", "application/json")
        self.finish(json.dumps(result))
示例#39
0
文件: views.py 项目: Gr1N/sc-web
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')
示例#40
0
文件: api.py 项目: SABilida/sc-web
    def post(self):
        sctp_client = new_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 serialize_error(self, 404, 'Timeout waiting for answer')
            
            answer = logic.find_answer(question_addr, keynode_nrel_answer, sctp_client)
        
        if answer is None:
            return 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 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_id()})
    
        sctp_client.shutdown()
        self.set_header("Content-Type", "application/json")
        self.finish(result) 
示例#41
0
文件: api.py 项目: DmitryKus/sc-web
    def post(self):
        result = '[]'
        sctp_client = new_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() }
            
        sctp_client.shutdown()
        self.set_header("Content-Type", "application/json")
        self.finish(json.dumps(result))
示例#42
0
文件: api.py 项目: DmitryKus/sc-web
    def post(self):
        sctp_client = new_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 serialize_error(self, 404, 'Timeout waiting for answer')
            
            answer = logic.find_answer(question_addr, keynode_nrel_answer, sctp_client)
        
        if answer is None:
            return 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 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_id()})
    
        sctp_client.shutdown()
        self.set_header("Content-Type", "application/json")
        self.finish(result)