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 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()
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))