def forwards_func(apps, schema_editor):
    org_ks={
      "Organization": {"name": "A test Organization", "website": "http://new_org.example.com", "description": ""}, 
      "KnowledgeServer": {"name": "A test OKS.", "netloc": "test.thekoa.org", "description": "It has some datasets and structures", "html_home": "", "html_disclaimer": ""}
     }
    KnowledgeServer.create_this_ks(org_ks)
    this_ks_d = KnowledgeServer.this_knowledge_server('default')
    
    dssContinentState=DataSetStructure()
    dssContinentState.name="Test Continent-SubContinent-State";
    dssContinentState.SetNotNullFields()
    dssContinentState.save()

    mmContinent=dssContinentState.create_model_metadata(name="Continent",module="test1",name_field="name",description_field="")
    mmSubContinent=dssContinentState.create_model_metadata(name="SubContinent",module="test1",name_field="name",description_field="")
    mmState=dssContinentState.create_model_metadata(name="State",module="test1",name_field="name",description_field="")
    
    # It creates ModelMetadata and a DataSet for each of them; having the DataSetStructure makes it
    # possible to release and materialize the datasets with dangling references that will be
    # resolved once the dss is released and materialized. 
    KnowledgeServer.register_models([mmContinent, mmSubContinent, mmState])
     
    # it creates the root node from the ModelMetadata provided
    dssContinentState.root_model_metadata(mmContinent)
    # child nodes for two attributes/fields
    dssContinentState.root_node.children_for(["subcontinent_set", "state_set"], this_ks_d.netloc)
    dssContinentState.save()
    
    dss_dss = DataSetStructure.get_from_name(DataSetStructure.dataset_structure_DSN)
    
    ds = DataSet(description='DataSet for data set structure "Continent-SubContinent-State"', knowledge_server=this_ks_d, dataset_structure=dss_dss, root=dssContinentState, version_major=0, version_minor=1, version_patch=0, version_description="")
    ds.save();
    ds.set_released()
        
    europe = Continent();europe.name="Europe";europe.save()
    asia = Continent();asia.name="Asia";asia.save()
    south_europe=SubContinent();south_europe.name="South Europe";south_europe.continent=europe;south_europe.save()
    central_europe=SubContinent();central_europe.name="Central Europe";central_europe.continent=europe;central_europe.save()
    italy=State();italy.name="Italy";italy.sub_continent=south_europe;italy.continent=europe;italy.save()
    spain=State();spain.name="Spain";spain.sub_continent=south_europe;spain.continent=europe;spain.save()
    germany=State();germany.name="Germany";germany.sub_continent=central_europe;germany.continent=europe;germany.save()
    
    ds = DataSet(knowledge_server=this_ks_d,dataset_structure=dssContinentState,root=europe,
                 description="Europe",version_major=0,version_minor=1,version_patch=0,version_description="")
    ds.save();ds.set_released(); 
    ds = DataSet(knowledge_server=this_ks_d,dataset_structure=dssContinentState,root=asia,
                 description="Asia",version_major=0,version_minor=1,version_patch=0,version_description="")
    ds.save();ds.set_released(); 
def forwards_func(apps, schema_editor):
    this_ks_d = KnowledgeServer.this_knowledge_server('default')

    dss_workflow = DataSetStructure(name='Workflow')
    dss_workflow.description = 'Workflow-Method-Attribute-PermissionStatement'
    dss_workflow.SetNotNullFields()
    dss_workflow.save()

    mm_workflow = Workflow().get_model_metadata(db_alias='default')
    mm_workflow_method = dss_workflow.create_model_metadata(name="WorkflowMethod",module="ap",name_field="name",description_field="description")
    mm_attribute = dss_workflow.create_model_metadata(name="Attribute",module="ap",name_field="",description_field="")
    mm_widget = dss_workflow.create_model_metadata(name="Widget",module="ap",name_field="",description_field="")
    mm_attribute_in_a_method = dss_workflow.create_model_metadata(name="AttributeInAMethod",module="ap",name_field="",description_field="")
    mm_permission_statement = dss_workflow.create_model_metadata(name="PermissionStatement",module="ap",name_field="",description_field="")
    mm_permission_holder = dss_workflow.create_model_metadata(name="PermissionHolder",module="ap",name_field="",description_field="")

    # It creates a DataSet for each of them; having the DataSetStructure makes it
    # possible to release and materialize the datasets with dangling references that will be
    # resolved once the dss is released and materialized. 
    KnowledgeServer.register_models([mm_workflow_method, mm_attribute_in_a_method, mm_permission_statement, mm_attribute, mm_widget, mm_permission_holder])

    # it creates the root node from the ModelMetadata provided
    dss_workflow.root_model_metadata(mm_workflow)
    # child nodes for two attributes/fields
    dss_workflow.root_node.children_nodes_for(["methods"], this_ks_d.netloc)
    dss_workflow.root_node.children_external_references_nodes_for( [ "type" ], this_ks_d.netloc )

    method_node = dss_workflow.root_node.child_nodes.all()[0]
    method_node.children_external_references_nodes_for(["initial_statuses", "final_status"], this_ks_d.netloc)
    method_node.children_nodes_for(["attributeinamethod_set", "permission"], this_ks_d.netloc)
    attribute_in_a_method_node = [cn for cn in method_node.child_nodes.all() if cn.attribute == "attributeinamethod_set"][0]
    attribute_in_a_method_node.children_external_references_nodes_for( [ "attribute", "custom_widget" ], this_ks_d.netloc )

    permission_node = [cn for cn in method_node.child_nodes.all() if cn.attribute == "permission"][0]
    permission_node.children_external_references_nodes_for( [ "permission_holder" ], this_ks_d.netloc )

    dss_workflow.save()
    
    dss_dss = DataSetStructure.get_from_name(DataSetStructure.dataset_structure_DSN)
    ds = DataSet(description='DataSet for data set structure "Workflow-Method-Attribute-PermissionStatement"', knowledge_server=this_ks_d, dataset_structure=dss_dss, root=dss_workflow, version_major=0, version_minor=1, version_patch=0, version_description="")
    ds.save()
    ds.set_released()
        

    # Application now is on its own dataset structure so we don't create it and just use the shallow one
    mm_application = dss_workflow.create_model_metadata(name='Application',module='ap',name_field="name",description_field="description")
    KnowledgeServer.register_models([mm_application])
Beispiel #3
0
def forwards_func(apps, schema_editor):
    org_ks = {
        "Organization": {
            "name": "A test Organization",
            "website": "http://new_org.example.com",
            "description": ""
        },
        "KnowledgeServer": {
            "name": "A test OKS.",
            "netloc": "test.thekoa.org",
            "description": "It has some datasets and structures",
            "html_home": "",
            "html_disclaimer": ""
        }
    }
    KnowledgeServer.create_this_ks(org_ks)
    this_ks_d = KnowledgeServer.this_knowledge_server('default')

    dssContinentState = DataSetStructure()
    dssContinentState.name = "Test Continent-SubContinent-State"
    dssContinentState.SetNotNullFields()
    dssContinentState.save()

    mmContinent = dssContinentState.create_model_metadata(
        "Continent", "test1", "name")
    mmSubContinent = dssContinentState.create_model_metadata(
        "SubContinent", "test1", "name")
    mmState = dssContinentState.create_model_metadata("State", "test1", "name")

    # It creates ModelMetadata and a DataSet for each of them; having the DataSetStructure makes it
    # possible to release and materialize the datasets with dangling references that will be
    # resolved once the dss is released and materialized.
    KnowledgeServer.register_models([mmContinent, mmSubContinent, mmState])

    # it creates the root node of the dataset structure
    dssContinentState.root_model_metadata(mmContinent)
    # and child nodes for two attributes/fields
    dssContinentState.root_node.children_nodes_for(
        ["subcontinent_set", "state_set"], this_ks_d.netloc)
    dssContinentState.save()

    dss_dss = DataSetStructure.get_from_name(
        DataSetStructure.dataset_structure_DSN)

    ds = DataSet(
        description=
        'DataSet for data set structure "Continent-SubContinent-State"',
        knowledge_server=this_ks_d,
        dataset_structure=dss_dss,
        root=dssContinentState,
        version_major=0,
        version_minor=1,
        version_patch=0)
    ds.save()
    ds.set_released()

    europe = Continent()
    europe.name = "Europe"
    europe.save()
    asia = Continent()
    asia.name = "Asia"
    asia.save()
    south_europe = SubContinent()
    south_europe.name = "South Europe"
    south_europe.continent = europe
    south_europe.save()
    central_europe = SubContinent()
    central_europe.name = "Central Europe"
    central_europe.continent = europe
    central_europe.save()
    italy = State()
    italy.name = "Italy"
    italy.sub_continent = south_europe
    italy.continent = europe
    italy.save()
    spain = State()
    spain.name = "Spain"
    spain.sub_continent = south_europe
    spain.continent = europe
    spain.save()
    germany = State()
    germany.name = "Germany"
    germany.sub_continent = central_europe
    germany.continent = europe
    germany.save()

    ds = DataSet(knowledge_server=this_ks_d,
                 dataset_structure=dssContinentState,
                 root=europe,
                 description="Europe",
                 version_major=0,
                 version_minor=1,
                 version_patch=0,
                 version_description="")
    ds.save()
    ds.set_released()
    ds = DataSet(knowledge_server=this_ks_d,
                 dataset_structure=dssContinentState,
                 root=asia,
                 description="Asia",
                 version_major=0,
                 version_minor=1,
                 version_patch=0,
                 version_description="")
    ds.save()
    ds.set_released()
Beispiel #4
0
def forwards_func(apps, schema_editor):
    this_ks_d = KnowledgeServer.this_knowledge_server('default')

    dss_workflow = DataSetStructure(name='Workflow')
    dss_workflow.description = 'Workflow-Method-Attribute-PermissionStatement'
    dss_workflow.SetNotNullFields()
    dss_workflow.save()

    mm_workflow = Workflow().get_model_metadata(db_alias='default')
    models_for_dss_workflow = [
        {
            "name": "Attribute",
            "module": "ap",
            "name_field": "",
            "description_field": ""
        },
        {
            "name": "Widget",
            "module": "ap",
            "name_field": "",
            "description_field": ""
        },
        {
            "name": "AttributeInAMethod",
            "module": "ap",
            "name_field": "",
            "description_field": ""
        },
        {
            "name": "PermissionStatement",
            "module": "ap",
            "name_field": "",
            "description_field": ""
        },
    ]
    mm_attribute, mm_widget, mm_attribute_in_a_method, mm_permission_statement, mm_permission_holder = dss_workflow.create_many_model_metadata(
        models_for_dss_workflow)

    mm_workflow_method = dss_workflow.create_model_metadata(
        name="WorkflowMethod", module="ap")
    mm_attribute = dss_workflow.create_model_metadata(name="Attribute",
                                                      module="ap",
                                                      name_field="",
                                                      description_field="")
    mm_widget = dss_workflow.create_model_metadata(name="Widget",
                                                   module="ap",
                                                   name_field="",
                                                   description_field="")
    mm_attribute_in_a_method = dss_workflow.create_model_metadata(
        name="AttributeInAMethod",
        module="ap",
        name_field="",
        description_field="")
    mm_permission_statement = dss_workflow.create_model_metadata(
        name="PermissionStatement",
        module="ap",
        name_field="",
        description_field="")
    # check quale DSS
    mm_attribute_type = dss_workflow.create_model_metadata(
        name="AttributeType", module="ap")
    mm_attribute_group = dss_workflow.create_model_metadata(
        name="AttributeGroup", module="ap")
    # WorkflowsMethods è un many to many through, va fatto ?
    WorkflowTransition
    Application
    ModelMetadataSearch
    ApplicationStructureNodeSearch
    AttributeInASearch
    KSUser
    KSRole
    KSGroup
    # check quale DSS; sul diagramma sul foglio?

    # It creates a DataSet for each of them; having the DataSetStructure makes it
    # possible to release and materialize the datasets with dangling references that will be
    # resolved once the dss is released and materialized.
    KnowledgeServer.register_models([
        mm_workflow_method, mm_attribute_in_a_method, mm_permission_statement,
        mm_attribute, mm_attribute_type, mm_attribute_group, mm_widget,
        mm_permission_holder
    ])

    # it creates the root node from the ModelMetadata provided
    dss_workflow.root_model_metadata(mm_workflow)
    # child nodes for two attributes/fields
    dss_workflow.root_node.children_nodes_for(["methods"], this_ks_d.netloc)
    dss_workflow.root_node.children_external_references_nodes_for(
        ["type"], this_ks_d.netloc)

    method_node = dss_workflow.root_node.child_nodes.all()[0]
    method_node.children_external_references_nodes_for(
        ["initial_statuses", "final_status"], this_ks_d.netloc)
    method_node.children_nodes_for(["attributeinamethod_set", "permission"],
                                   this_ks_d.netloc)
    attribute_in_a_method_node = [
        cn for cn in method_node.child_nodes.all()
        if cn.attribute == "attributeinamethod_set"
    ][0]
    attribute_in_a_method_node.children_external_references_nodes_for(
        ["attribute", "custom_widget"], this_ks_d.netloc)

    permission_node = [
        cn for cn in method_node.child_nodes.all()
        if cn.attribute == "permission"
    ][0]
    permission_node.children_external_references_nodes_for(
        ["permission_holder"], this_ks_d.netloc)

    dss_workflow.save()

    dss_dss = DataSetStructure.get_from_name(
        DataSetStructure.dataset_structure_DSN)
    ds = DataSet(
        description=
        'DataSet for data set structure "Workflow-Method-Attribute-PermissionStatement"',
        knowledge_server=this_ks_d,
        dataset_structure=dss_dss,
        root=dss_workflow,
        version_major=0,
        version_minor=1,
        version_patch=0,
        version_description="")
    ds.save()
    ds.set_released()

    # Application now is on its own dataset structure so we don't create it and just use the shallow one
    mm_application = dss_workflow.create_model_metadata(
        name='Application',
        module='ap',
        name_field="name",
        description_field="description")
    KnowledgeServer.register_models([mm_application])
def debug(request):
    '''
    created to debug code

    Args:
        request: 
    '''
    UKCL = request.GET["UKCL"]
    return HttpResponse("OK: " + UKCL)
    try:
        from django.core import management
        #         management.call_command('migrate', "--database=materialized", interactive=False)
        #         management.call_command('migrate', 'ap', interactive=False)
        #         management.call_command('migrate', interactive=False)
        management.call_command('migrate', 'ap', interactive=False)
        # funziona?        management.call_command('migrate', "knowledge_server 0003_initial_data --database=materialized", interactive=False)
        return HttpResponse("OK")

        import scrapy

        class DmozItem(scrapy.Item):
            title = scrapy.Field()
            link = scrapy.Field()
            desc = scrapy.Field()

        class DmozSpider(scrapy.Spider):
            name = "dmoz"
            allowed_domains = ["dmoz.org"]
            start_urls = [
                "http://www.dmoz.org/Computers/Programming/Languages/Python/",
            ]

            def parse(self, response):
                for href in response.css(
                        "ul.directory.dir-col > li > a::attr('href')"):
                    url = response.urljoin(href.extract())
                    yield scrapy.Request(url, callback=self.parse_dir_contents)

            def parse_dir_contents(self, response):
                for sel in response.xpath('//ul/li'):
                    item = DmozItem()
                    item['title'] = sel.xpath('a/text()').extract()
                    item['link'] = sel.xpath('a/@href').extract()
                    item['desc'] = sel.xpath('text()').extract()
                    yield item

        return HttpResponse('OK')

        ar = ApiResponse()
        ar.content = {"DataSet": "Versions"}
        ar.status = ApiResponse.success
        return HttpResponse(ar.json(), content_type="application/json")

        # TODO: AGGIORNARE SU STACKOVERFLOW: http://stackoverflow.com/questions/8784400/clearing-specific-cache-in-django

        from licenses.models import License
        db_alias = 'default'
        ccbysa40 = License.objects.using(db_alias).get(
            short_name="CC-BY-SA-4.0")
        dssModelMetadataFields = DataSetStructure.get_from_name(
            DataSetStructure.model_metadata_DSN, db_alias)
        dssDataSetStructureStructureNode = DataSetStructure.get_from_name(
            DataSetStructure.dataset_structure_DSN, db_alias)
        dssOrganizationKS = DataSetStructure.get_from_name(
            DataSetStructure.organization_DSN, db_alias)
        for ds in DataSet.objects.using(db_alias).filter(
                dataset_structure=dssModelMetadataFields):
            ds.licenses.add(ccbysa40)
            ds.save()
        for ds in DataSet.objects.using(db_alias).filter(
                dataset_structure=dssDataSetStructureStructureNode):
            ds.licenses.add(ccbysa40)
            ds.save()
        for ds in DataSet.objects.using(db_alias).filter(
                dataset_structure=dssOrganizationKS):
            ds.licenses.add(ccbysa40)
            ds.save()
        db_alias = 'materialized'
        ccbysa40 = License.objects.using(db_alias).get(
            short_name="CC-BY-SA-4.0")
        dssModelMetadataFields = DataSetStructure.get_from_name(
            DataSetStructure.model_metadata_DSN, db_alias)
        dssDataSetStructureStructureNode = DataSetStructure.get_from_name(
            DataSetStructure.dataset_structure_DSN, db_alias)
        dssOrganizationKS = DataSetStructure.get_from_name(
            DataSetStructure.organization_DSN, db_alias)
        for ds in DataSet.objects.using(db_alias).filter(
                dataset_structure=dssModelMetadataFields):
            ds.licenses.add(ccbysa40)
            ds.save()
        for ds in DataSet.objects.using(db_alias).filter(
                dataset_structure=dssDataSetStructureStructureNode):
            ds.licenses.add(ccbysa40)
            ds.save()
        for ds in DataSet.objects.using(db_alias).filter(
                dataset_structure=dssOrganizationKS):
            ds.licenses.add(ccbysa40)
            ds.save()
        return HttpResponse("OK ")

        from django.core.cache import cache
        from django.utils.cache import get_cache_key, _generate_cache_header_key
        from django.utils.encoding import escape_uri_path
        from django.http import HttpRequest

        new_request = HttpRequest()
        new_request.path = 'root.beta.thekoa.org/oks/api/ks_info/JSON/'  ##this path works
        new_request.META['SERVER_PORT'] = request.META['SERVER_PORT']
        new_request.META['SERVER_NAME'] = request.META['SERVER_NAME']

        key = _generate_cache_header_key("", new_request)
        if cache.has_key(key):
            cache.delete(key)

        full_path = 'http://root.beta.thekoa.org/oks/api/datasets/http%253A%252F%252Froot.beta.thekoa.org%252Fknowledge_server%252FDataSetStructure%252F4/JSON/'
        import hashlib
        from django.utils.encoding import force_bytes, iri_to_uri
        from django.utils.cache import _i18n_cache_key_suffix
        # code from _generate_cache_header_key
        url = hashlib.md5(force_bytes(iri_to_uri(full_path)))
        cache_key = 'views.decorators.cache.cache_header.%s.%s' % (
            "", url.hexdigest())
        key = _i18n_cache_key_suffix(request, cache_key)
        if cache.has_key(key):
            cache.delete(key)

        return HttpResponse("OK ")
        #         d = DataSet.objects.get(pk=1)
        #         s = d.shallow_structure()
        #         rct = d.root_content_type
        #
        #
        #         for structure_child_node in s.root_node.child_nodes.all():
        #             mm = structure_child_node.sn_model_metadata(d)
        #             print(mm.name)

        dssContinentState = DataSetStructure()
        dssContinentState.name = "Test Continent-SubContinent-State"
        dssContinentState.SetNotNullFields()
        dssContinentState.save()

        return HttpResponse("OK ")
    except Exception as ex:
        logger.error("views.debug: " + str(ex))
        return HttpResponse(str(ex))