def populate_project_form(form: ProjectForm, project_node: Node): title = '' abstract = '' if project_node: title_node = project_node.find_child(names.TITLE) if title_node: title = title_node.content abstract_node = project_node.find_child(names.ABSTRACT) if abstract_node: abstract = abstract_node.content if not abstract: para_node = abstract_node.find_child(names.PARA) if para_node: abstract = para_node.content else: section_node = abstract_node.find_child(names.SECTION) if section_node: abstract = section_node.content abstract = abstract form.title.data = title form.abstract.data = remove_paragraph_tags(abstract) form.md5.data = form_md5(form)
def populate_method_step_form(form: MethodStepForm, ms_node: Node): description = '' instrumentation = '' if ms_node: description_node = ms_node.find_child(names.DESCRIPTION) if description_node: if description_node.content: description = description_node.content else: section_node = description_node.find_child(names.SECTION) if section_node: description = remove_paragraph_tags(section_node.content) else: para_node = description_node.find_child(names.PARA) if para_node: description = para_node.content instrumentation_node = ms_node.find_child(names.INSTRUMENTATION) if instrumentation_node: instrumentation = instrumentation_node.content form.description.data = remove_paragraph_tags(description) form.instrumentation.data = instrumentation form.md5.data = form_md5(form)
def populate_taxonomic_coverage_form(form: TaxonomicCoverageForm, node: Node): general_taxonomic_coverage_node = node.find_child( names.GENERALTAXONOMICCOVERAGE) if general_taxonomic_coverage_node: form.general_taxonomic_coverage.data = general_taxonomic_coverage_node.content hierarchy = [] taxonomic_classification_node = node.find_child( names.TAXONOMICCLASSIFICATION) populate_taxonomic_coverage_form_aux(hierarchy, taxonomic_classification_node) form.hierarchy.data = hierarchy[::-1] first_taxon = hierarchy[-1] form.taxon_value.data = first_taxon[1] taxon_rank = first_taxon[0].capitalize() if (taxon_rank, taxon_rank) in form.taxon_rank.choices: form.taxon_rank.data = taxon_rank if first_taxon[5]: form.taxonomic_authority.data = first_taxon[5] have_links = False for taxon in hierarchy: if taxon[4]: have_links = True break form.md5.data = form_md5(form) return have_links
def populate_method_step_form(form: MethodStepForm, ms_node: Node): description = '' instrumentation = '' data_sources = '' if ms_node: description_node = ms_node.find_child(names.DESCRIPTION) if description_node: description = display_texttype_node(description_node) if data_sources_marker_begin in description and data_sources_marker_end in description: begin = description.find(data_sources_marker_begin) end = description.find(data_sources_marker_end) data_sources = description[begin + len(data_sources_marker_begin) + 1:end - 1] description = description[0:begin - 1] instrumentation_node = ms_node.find_child(names.INSTRUMENTATION) if instrumentation_node: instrumentation = instrumentation_node.content form.description.data = description form.instrumentation.data = instrumentation form.data_sources.data = data_sources form.md5.data = form_md5(form)
def populate_access_rule_form(form: AccessForm, allow_node: Node): userid = '' permission = '' if allow_node: principal_node = allow_node.find_child(names.PRINCIPAL) if principal_node: userid = principal_node.content permission_node = allow_node.find_child(names.PERMISSION) if permission_node: permission = permission_node.content form.userid.data = userid form.permission.data = permission form.md5.data = form_md5(form)
def check_data_table(eml_node, filename, data_table_node: Node): link = url_for(PAGE_DATA_TABLE, filename=filename, node_id=data_table_node.id) validation_errs = validate_via_metapype(data_table_node) check_data_table_md5_checksum(data_table_node, link) if find_min_unmet(validation_errs, names.DATATABLE, names.ENTITYNAME): add_to_evaluation('data_table_01', link) if find_min_unmet(validation_errs, names.DATATABLE, names.ENTITYDESCRIPTION): add_to_evaluation('data_table_02', link) if find_min_unmet(validation_errs, names.PHYSICAL, names.OBJECTNAME): add_to_evaluation('data_table_03', link) if find_min_unmet(validation_errs, names.DATATABLE, names.ATTRIBUTELIST): add_to_evaluation('data_table_04', link) evaluation_warnings = evaluate_via_metapype(data_table_node) if find_err_code(evaluation_warnings, EvaluationWarning.DATATABLE_DESCRIPTION_MISSING, names.DATATABLE): add_to_evaluation('data_table_02', link) attribute_list_node = data_table_node.find_child(names.ATTRIBUTELIST) if attribute_list_node: attribute_nodes = attribute_list_node.find_all_children( names.ATTRIBUTE) for attribute_node in attribute_nodes: check_attribute(eml_node, filename, data_table_node, attribute_node)
def populate_maintenance_form(form: MaintenanceForm, maintenance_node: Node): description = '' update_frequency = '' if maintenance_node: description_node = maintenance_node.find_child(names.DESCRIPTION) if description_node: description = display_texttype_node(description_node) update_frequency_node = maintenance_node.find_child(names.MAINTENANCEUPDATEFREQUENCY) if update_frequency_node: update_frequency = update_frequency_node.content form.description.data = description form.update_frequency.data = update_frequency form.md5.data = form_md5(form)
def get_attribute_type(attrib_node: Node): mscale_node = attrib_node.find_child(names.MEASUREMENTSCALE) # Formerly, Categorical variables were nominal. But now that we're importing externally created XML # files, they may be ordinal. nominal_or_ordinal_node = mscale_node.find_child(names.NOMINAL) if not nominal_or_ordinal_node: nominal_or_ordinal_node = mscale_node.find_child(names.ORDINAL) if nominal_or_ordinal_node: enumerated_domain_node = nominal_or_ordinal_node.find_single_node_by_path( [names.NONNUMERICDOMAIN, names.ENUMERATEDDOMAIN]) if enumerated_domain_node: return metapype_client.VariableType.CATEGORICAL text_domain_node = nominal_or_ordinal_node.find_single_node_by_path( [names.NONNUMERICDOMAIN, names.TEXTDOMAIN]) if text_domain_node: return metapype_client.VariableType.TEXT # Formerly, Numerical variables were ratio. But now that we're importing externally created XML # files, they may be interval. ratio_or_interval_node = mscale_node.find_child(names.RATIO) if not ratio_or_interval_node: ratio_or_interval_node = mscale_node.find_child(names.INTERVAL) if ratio_or_interval_node: return metapype_client.VariableType.NUMERICAL datetime_node = mscale_node.find_child(names.DATETIME) if datetime_node: return metapype_client.VariableType.DATETIME return None
def populate_taxonomic_coverage_form_aux(hierarchy, node: Node = None): if node: taxon_rank_name_node = node.find_child(names.TAXONRANKNAME) taxon_rank_value_node = node.find_child(names.TAXONRANKVALUE) taxon_common_name_node = node.find_child(names.COMMONNAME) taxon_id_node = node.find_child(names.TAXONID) if taxon_rank_name_node: taxon_rank_name = taxon_rank_name_node.content else: taxon_rank_name = None if taxon_rank_value_node: taxon_rank_value = taxon_rank_value_node.content else: taxon_rank_value = None if taxon_common_name_node: taxon_common_name = taxon_common_name_node.content else: taxon_common_name = '' if taxon_id_node: taxon_id = taxon_id_node.content provider_uri = taxon_id_node.attribute_value(names.PROVIDER) else: taxon_id = None provider_uri = None if taxon_rank_name and taxon_rank_value: link = None provider = None if taxon_id: if provider_uri == "https://www.itis.gov": link = f'https://itis.gov/servlet/SingleRpt/SingleRpt?search_topic=TSN&search_value={taxon_id}' provider = 'ITIS' elif provider_uri == "https://www.ncbi.nlm.nih.gov/taxonomy": link = f'https://www.ncbi.nlm.nih.gov/Taxonomy/Browser/wwwtax.cgi?id={taxon_id}' provider = 'NCBI' elif provider_uri == "http://www.marinespecies.org": link = f'http://marinespecies.org/aphia.php?p=taxdetails&id={taxon_id}' provider = 'WORMS' hierarchy.append((taxon_rank_name, taxon_rank_value, taxon_common_name, taxon_id, link, provider)) taxonomic_classification_node = node.find_child( names.TAXONOMICCLASSIFICATION) if taxonomic_classification_node: populate_taxonomic_coverage_form_aux( hierarchy, taxonomic_classification_node)
def populate_project_form(form: ProjectForm, project_node: Node): title = '' abstract = '' if project_node: title_node = project_node.find_child(names.TITLE) if title_node: title = title_node.content abstract_node = project_node.find_child(names.ABSTRACT) post_process_texttype_node(abstract_node) funding_node = project_node.find_child(names.FUNDING) post_process_texttype_node(funding_node) form.title.data = title form.abstract.data = display_texttype_node(abstract_node) form.funding.data = display_texttype_node(funding_node) form.md5.data = form_md5(form)
def populate_geographic_coverage_form(form: GeographicCoverageForm, node: Node): geographic_description_node = node.find_child(names.GEOGRAPHICDESCRIPTION) if geographic_description_node: form.geographic_description.data = geographic_description_node.content wbc_node = node.find_single_node_by_path([ names.BOUNDINGCOORDINATES, names.WESTBOUNDINGCOORDINATE ]) if wbc_node: form.wbc.data = wbc_node.content ebc_node = node.find_single_node_by_path([ names.BOUNDINGCOORDINATES, names.EASTBOUNDINGCOORDINATE ]) if ebc_node: form.ebc.data = ebc_node.content nbc_node = node.find_single_node_by_path([ names.BOUNDINGCOORDINATES, names.NORTHBOUNDINGCOORDINATE ]) if nbc_node: form.nbc.data = nbc_node.content sbc_node = node.find_single_node_by_path([ names.BOUNDINGCOORDINATES, names.SOUTHBOUNDINGCOORDINATE ]) if sbc_node: form.sbc.data = sbc_node.content amin_node = node.find_single_node_by_path([ names.BOUNDINGCOORDINATES, names.BOUNDINGALTITUDES, names.ALTITUDEMINIMUM ]) if amin_node: form.amin.data = amin_node.content amax_node = node.find_single_node_by_path([ names.BOUNDINGCOORDINATES, names.BOUNDINGALTITUDES, names.ALTITUDEMAXIMUM ]) if amax_node: form.amax.data = amax_node.content aunits_node = node.find_single_node_by_path([ names.BOUNDINGCOORDINATES, names.BOUNDINGALTITUDES, names.ALTITUDEUNITS ]) if aunits_node: form.aunits.data = aunits_node.content form.md5.data = form_md5(form)
def maintenance(filename=None): form = MaintenanceForm(filename=filename) eml_node = load_eml(filename=filename) if eml_node: dataset_node = eml_node.find_child(names.DATASET) if not dataset_node: dataset_node = Node(names.DATASET, parent=eml_node) add_child(eml_node, dataset_node) # Process POST if request.method == 'POST' and BTN_CANCEL in request.form: url = url_for(PAGE_MAINTENANCE, filename=filename) return redirect(url) if request.method == 'POST' and form.validate_on_submit(): save = False if is_dirty_form(form): save = True if save: maintenace_description = form.description.data valid, msg = is_valid_xml_fragment(maintenace_description, names.MAINTENANCE) if not valid: flash(invalid_xml_error_message(msg, False, names.DESCRIPTION), 'error') return render_get_maintenance_page(eml_node, form, filename) update_frequency = form.update_frequency.data create_maintenance(dataset_node, maintenace_description, update_frequency) save_both_formats(filename=filename, eml_node=eml_node) form_value = request.form form_dict = form_value.to_dict(flat=False) new_page = PAGE_MAINTENANCE if form_dict: for key in form_dict: val = form_dict[key][0] # value is the first list element if val == BTN_SAVE_AND_CONTINUE: new_page = PAGE_PUBLISHER else: new_page = handle_hidden_buttons(new_page, PAGE_MAINTENANCE) return redirect(url_for(new_page, filename=filename)) # Process GET if dataset_node: maintenance_node = dataset_node.find_child(names.MAINTENANCE) if maintenance_node: populate_maintenance_form(form, maintenance_node) return render_get_maintenance_page(eml_node, form, filename)
def add_geo_coverage_node(eml_node, description, north, south, east, west): dataset_node = eml_node.find_child(names.DATASET) if not dataset_node: dataset_node = Node(names.DATASET) coverage_node = dataset_node.find_child(names.COVERAGE) if not coverage_node: coverage_node = Node(names.COVERAGE, parent=dataset_node) add_child(dataset_node, coverage_node) gc_node = Node(names.GEOGRAPHICCOVERAGE, parent=coverage_node) add_child(coverage_node, gc_node) create_geographic_coverage(gc_node, description, west, east, north, south)
def populate_award_form(form: AwardForm, award_node: Node): funder_name = '' award_title = '' funder_identifier = '' # FIX ME - should be list award_number = '' award_url = '' if award_node: funder_name_node = award_node.find_child(names.FUNDERNAME) if funder_name_node and funder_name_node.content: funder_name = funder_name_node.content award_title_node = award_node.find_child(names.TITLE) if award_title_node and award_title_node.content: award_title = award_title_node.content funder_identifiers = [] funder_identifier_nodes = award_node.find_all_children( names.FUNDERIDENTIFIER) for funder_identifier_node in funder_identifier_nodes: if funder_identifier_node.content: funder_identifiers.append(funder_identifier_node.content) funder_identifier = ','.join(funder_identifiers) award_number_node = award_node.find_child(names.AWARDNUMBER) if award_number_node and award_number_node.content: award_number = award_number_node.content award_url_node = award_node.find_child(names.AWARDURL) if award_url_node and award_url_node.content: award_url = award_url_node.content form.funder_name.data = funder_name form.award_title.data = award_title form.funder_identifier.data = funder_identifier form.award_number.data = award_number form.award_url.data = award_url
def get_attribute_type(attrib_node: Node): mscale_node = attrib_node.find_child(names.MEASUREMENTSCALE) nominal_node = mscale_node.find_child(names.NOMINAL) if nominal_node: enumerated_domain_node = nominal_node.find_single_node_by_path( [names.NONNUMERICDOMAIN, names.ENUMERATEDDOMAIN]) if enumerated_domain_node: return VariableType.CATEGORICAL text_domain_node = nominal_node.find_single_node_by_path( [names.NONNUMERICDOMAIN, names.TEXTDOMAIN]) if text_domain_node: return VariableType.TEXT ratio_node = mscale_node.find_child(names.RATIO) if ratio_node: return VariableType.NUMERICAL datetime_node = mscale_node.find_child(names.DATETIME) if datetime_node: return VariableType.DATETIME return None
def populate_temporal_coverage_form(form: TemporalCoverageForm, node: Node): begin_date_node = node.find_single_node_by_path( [names.RANGEOFDATES, names.BEGINDATE]) if begin_date_node: calendar_date_node = begin_date_node.find_child(names.CALENDARDATE) form.begin_date.data = calendar_date_node.content end_date_node = node.find_single_node_by_path( [names.RANGEOFDATES, names.ENDDATE]) if end_date_node: calendar_date_node = end_date_node.find_child(names.CALENDARDATE) form.end_date.data = calendar_date_node.content else: single_date_time_node = node.find_child(names.SINGLEDATETIME) if single_date_time_node: calendar_date_node = single_date_time_node.find_child( names.CALENDARDATE) form.begin_date.data = calendar_date_node.content form.md5.data = form_md5(form)
def temporal_coverage(filename=None, node_id=None): form = TemporalCoverageForm(filename=filename) tc_node_id = node_id # Process POST if request.method == 'POST' and BTN_CANCEL in request.form: url = url_for(PAGE_TEMPORAL_COVERAGE_SELECT, filename=filename) return redirect(url) if request.method == 'POST' and form.validate_on_submit(): save = False if is_dirty_form(form): save = True form_value = request.form form_dict = form_value.to_dict(flat=False) new_page = PAGE_TEMPORAL_COVERAGE_SELECT if form_dict: for key in form_dict: val = form_dict[key][0] # value is the first list element if val == BTN_HIDDEN_NEW: new_page = PAGE_CREATE break elif val == BTN_HIDDEN_OPEN: new_page = PAGE_OPEN break elif val == BTN_HIDDEN_CLOSE: new_page = PAGE_CLOSE break url = url_for(new_page, filename=filename) if save: eml_node = load_eml(filename=filename) dataset_node = eml_node.find_child(names.DATASET) if not dataset_node: dataset_node = Node(names.DATASET) coverage_node = dataset_node.find_child(names.COVERAGE) if not coverage_node: coverage_node = Node(names.COVERAGE, parent=dataset_node) add_child(dataset_node, coverage_node) tc_node = Node(names.TEMPORALCOVERAGE, parent=coverage_node) begin_date_str = form.begin_date.data end_date_str = form.end_date.data create_temporal_coverage(tc_node, begin_date_str, end_date_str) if node_id and len(node_id) != 1: old_tc_node = Node.get_node_instance(node_id) if old_tc_node: coverage_parent_node = old_tc_node.parent coverage_parent_node.replace_child(old_tc_node, tc_node) else: msg = f"No node found in the node store with node id {node_id}" raise Exception(msg) else: add_child(coverage_node, tc_node) tc_node_id = tc_node.id flash_msg = compare_begin_end_dates(begin_date_str, end_date_str) if flash_msg: flash(flash_msg) url = (url_for(PAGE_TEMPORAL_COVERAGE, filename=filename, node_id=tc_node_id)) save_both_formats(filename=filename, eml_node=eml_node) return redirect(url) # Process GET if node_id == '1': form.init_md5() else: eml_node = load_eml(filename=filename) dataset_node = eml_node.find_child(names.DATASET) if dataset_node: coverage_node = dataset_node.find_child(names.COVERAGE) if coverage_node: tc_nodes = coverage_node.find_all_children( names.TEMPORALCOVERAGE) if tc_nodes: for tc_node in tc_nodes: if node_id == tc_node.id: populate_temporal_coverage_form(form, tc_node) set_current_page('temporal_coverage') return render_template('temporal_coverage.html', title='Temporal Coverage', form=form)
def geographic_coverage(filename=None, node_id=None): form = GeographicCoverageForm(filename=filename) # Process POST if request.method == 'POST' and BTN_CANCEL in request.form: url = url_for(PAGE_GEOGRAPHIC_COVERAGE_SELECT, filename=filename) return redirect(url) if request.method == 'POST' and form.validate_on_submit(): submit_type = None if is_dirty_form(form): submit_type = 'Save Changes' form_value = request.form form_dict = form_value.to_dict(flat=False) new_page = PAGE_GEOGRAPHIC_COVERAGE_SELECT if form_dict: for key in form_dict: val = form_dict[key][0] # value is the first list element if val == BTN_HIDDEN_NEW: new_page = PAGE_CREATE break elif val == BTN_HIDDEN_OPEN: new_page = PAGE_OPEN break elif val == BTN_HIDDEN_CLOSE: new_page = PAGE_CLOSE break url = url_for(new_page, filename=filename) if submit_type == 'Save Changes': eml_node = load_eml(filename=filename) dataset_node = eml_node.find_child(names.DATASET) if not dataset_node: dataset_node = Node(names.DATASET) coverage_node = dataset_node.find_child(names.COVERAGE) if not coverage_node: coverage_node = Node(names.COVERAGE, parent=dataset_node) add_child(dataset_node, coverage_node) geographic_description = form.geographic_description.data wbc = form.wbc.data if form.wbc.data is not None else '' ebc = form.ebc.data if form.ebc.data is not None else '' nbc = form.nbc.data if form.nbc.data is not None else '' sbc = form.sbc.data if form.sbc.data is not None else '' gc_node = Node(names.GEOGRAPHICCOVERAGE, parent=coverage_node) create_geographic_coverage(gc_node, geographic_description, wbc, ebc, nbc, sbc) if node_id and len(node_id) != 1: old_gc_node = Node.get_node_instance(node_id) if old_gc_node: coverage_parent_node = old_gc_node.parent coverage_parent_node.replace_child(old_gc_node, gc_node) else: msg = f"No node found in the node store with node id {node_id}" raise Exception(msg) else: add_child(coverage_node, gc_node) if nbc and sbc and nbc < sbc: flash('North should be greater than or equal to South') url = (url_for(PAGE_GEOGRAPHIC_COVERAGE, filename=filename, node_id=gc_node.id)) if ebc and wbc and ebc < wbc: flash('East should be greater than or equal to West') url = (url_for(PAGE_GEOGRAPHIC_COVERAGE, filename=filename, node_id=gc_node.id)) save_both_formats(filename=filename, eml_node=eml_node) return redirect(url) # Process GET if node_id == '1': form.init_md5() else: eml_node = load_eml(filename=filename) dataset_node = eml_node.find_child(names.DATASET) if dataset_node: coverage_node = dataset_node.find_child(names.COVERAGE) if coverage_node: gc_nodes = coverage_node.find_all_children( names.GEOGRAPHICCOVERAGE) if gc_nodes: for gc_node in gc_nodes: if node_id == gc_node.id: populate_geographic_coverage_form(form, gc_node) set_current_page('geographic_coverage') help = [ get_help('geographic_coverages'), get_help('geographic_description'), get_help('bounding_coordinates') ] return render_template('geographic_coverage.html', title='Geographic Coverage', form=form, help=help)
def project(filename=None, project_node_id=None): form = ProjectForm(filename=filename) eml_node = load_eml(filename=filename) if eml_node: dataset_node = eml_node.find_child(names.DATASET) if not dataset_node: dataset_node = Node(names.DATASET, parent=eml_node) add_child(eml_node, dataset_node) doing_related_project = project_node_id # Process POST if request.method == 'POST' and form.validate_on_submit(): save = False if is_dirty_form(form): save = True # if not node_id: if not doing_related_project: this_page = PAGE_PROJECT else: this_page = PAGE_RELATED_PROJECT_SELECT # FIXME? new_page = None if 'Next' in request.form: # if not node_id: if not doing_related_project: new_page = PAGE_OTHER_ENTITY_SELECT else: new_page = PAGE_RELATED_PROJECT_SELECT elif BTN_PROJECT_PERSONNEL in request.form: new_page = PAGE_PROJECT_PERSONNEL_SELECT elif BTN_FUNDING_AWARDS in request.form: new_page = PAGE_FUNDING_AWARD_SELECT elif BTN_RELATED_PROJECTS in request.form: new_page = PAGE_RELATED_PROJECT_SELECT # doing_related_project = True else: new_page = handle_hidden_buttons(new_page, this_page) if save: abstract = form.abstract.data valid, msg = is_valid_xml_fragment(abstract, names.ABSTRACT) if not valid: flash(invalid_xml_error_message(msg, False, names.ABSTRACT), 'error') return render_get_project_page(eml_node, form, filename, doing_related_project, project_node_id) funding = form.funding.data valid, msg = is_valid_xml_fragment(funding, names.FUNDING) if not valid: flash(invalid_xml_error_message(msg, False, names.FUNDING), 'error') return render_get_project_page(eml_node, form, filename, doing_related_project, project_node_id) title = form.title.data if not doing_related_project: create_project(dataset_node, title, abstract, funding) else: related_project_node = create_related_project( dataset_node, title, abstract, funding, project_node_id) project_node_id = related_project_node.id save_both_formats(filename=filename, eml_node=eml_node) # if not node_id: if not doing_related_project: return redirect(url_for(new_page, filename=filename)) else: # return redirect(url_for(new_page, filename=filename, node_id=None, project_node_id=project_node_id)) return redirect( url_for(new_page, filename=filename, node_id='None', project_node_id=project_node_id)) # Process GET if project_node_id == '1': form.init_md5() elif doing_related_project: related_project_node = Node.get_node_instance(project_node_id) populate_project_form(form, related_project_node) elif dataset_node: project_node = dataset_node.find_child(names.PROJECT) populate_project_form(form, project_node) return render_get_project_page(eml_node, form, filename, doing_related_project, project_node_id)
def responsible_party(filename=None, node_id=None, method=None, node_name=None, back_page=None, title=None, next_page=None, save_and_continue=False, help=None, project_node_id=None): if BTN_CANCEL in request.form: if not project_node_id: url = url_for(back_page, filename=filename) else: url = url_for(back_page, filename=filename, node_id=project_node_id) return redirect(url) form = ResponsiblePartyForm(filename=filename) eml_node = load_eml(filename=filename) dataset_node = eml_node.find_child(names.DATASET) if not dataset_node: dataset_node = Node(names.DATASET, parent=eml_node) add_child(eml_node, dataset_node) parent_node = dataset_node role = False new_page = select_new_page(back_page, next_page) # new_page = back_page form_value = request.form form_dict = form_value.to_dict(flat=False) url = select_post(filename, form, form_dict, 'POST', PAGE_PUBLISHER, PAGE_MAINTENANCE, PAGE_PUBLICATION_INFO, PAGE_PUBLISHER, project_node_id=project_node_id) # If this is an associatedParty or a project personnel element, # set role to True so it will appear as a form field. if node_name == names.ASSOCIATEDPARTY or node_name == names.PERSONNEL: role = True # If this is a project personnel party, place it under the # project node, not under the dataset node if node_name == names.PERSONNEL: if not project_node_id: project_node = dataset_node.find_child(names.PROJECT) if not project_node: project_node = Node(names.PROJECT, parent=dataset_node) add_child(dataset_node, project_node) parent_node = project_node else: parent_node = Node.get_node_instance(project_node_id) # Process POST save = False if is_dirty_form(form): save = True if form.validate_on_submit(): if save: salutation = form.salutation.data gn = form.gn.data mn = form.mn.data sn = form.sn.data user_id = form.user_id.data organization = form.organization.data position_name = form.position_name.data address_1 = form.address_1.data address_2 = form.address_2.data city = form.city.data state = form.state.data postal_code = form.postal_code.data country = form.country.data phone = form.phone.data fax = form.fax.data email = form.email.data online_url = form.online_url.data role = form.role.data rp_node = Node(node_name, parent=parent_node) create_responsible_party( rp_node, filename, salutation, gn, mn, sn, user_id, organization, position_name, address_1, address_2, city, state, postal_code, country, phone, fax, email, online_url, role) if node_id and len(node_id) != 1: old_rp_node = Node.get_node_instance(node_id) if old_rp_node: old_rp_parent_node = old_rp_node.parent old_rp_parent_node.replace_child(old_rp_node, rp_node) else: msg = f"No node found in the node store with node id {node_id}" raise Exception(msg) else: add_child(parent_node, rp_node) save_both_formats(filename=filename, eml_node=eml_node) # flash(f"Changes to the '{node_name}' element have been saved.") # There is at most only one publisher element, so we don't have a # list of publishers to navigate back to. Stay on this page after # saving changes. # FIXME if node_name == names.PUBLISHER: new_page = PAGE_PUBLICATION_INFO if node_name != names.PUBLISHER: return redirect(url_for(new_page, filename=filename, node_id=project_node_id)) else: return redirect(url) # Process GET if node_id == '1': form.init_md5() else: if parent_node: rp_nodes = parent_node.find_all_children(child_name=node_name) if rp_nodes: for rp_node in rp_nodes: if node_id == rp_node.id: populate_responsible_party_form(form, rp_node) if project_node_id: title = 'Related ' + title help = get_helps([node_name]) return render_template('responsible_party.html', title=title, node_name=node_name, form=form, role=role, next_page=next_page, save_and_continue=save_and_continue, help=help)
def project(filename=None, node_id=None): form = ProjectForm(filename=filename) eml_node = load_eml(filename=filename) if eml_node: dataset_node = eml_node.find_child(names.DATASET) if not dataset_node: dataset_node = Node(names.DATASET, parent=eml_node) add_child(eml_node, dataset_node) # Process POST if request.method == 'POST' and form.validate_on_submit(): save = False if is_dirty_form(form): save = True # flash(f'save: {save}') if 'Next' in request.form: if not node_id: new_page = PAGE_OTHER_ENTITY_SELECT else: new_page = PAGE_RELATED_PROJECT_SELECT elif BTN_PROJECT_PERSONNEL in request.form: new_page = PAGE_PROJECT_PERSONNEL_SELECT elif BTN_FUNDING_AWARDS in request.form: new_page = PAGE_FUNDING_AWARD_SELECT elif BTN_RELATED_PROJECTS in request.form: new_page = PAGE_RELATED_PROJECT_SELECT elif BTN_HIDDEN_CHECK in request.form: new_page = PAGE_CHECK elif BTN_HIDDEN_SAVE in request.form: new_page = PAGE_PROJECT elif BTN_HIDDEN_DOWNLOAD in request.form: new_page = PAGE_DOWNLOAD elif BTN_HIDDEN_NEW in request.form: new_page = PAGE_CREATE elif BTN_HIDDEN_OPEN in request.form: new_page = PAGE_OPEN elif BTN_HIDDEN_CLOSE in request.form: new_page = PAGE_CLOSE if save: title = form.title.data abstract = add_paragraph_tags(form.abstract.data) if not node_id: create_project(dataset_node, title, abstract) else: related_project_node = create_related_project( dataset_node, title, abstract, node_id) node_id = related_project_node.id save_both_formats(filename=filename, eml_node=eml_node) if not node_id: return redirect(url_for(new_page, filename=filename)) else: return redirect( url_for(new_page, filename=filename, node_id=node_id)) # Process GET if node_id == '1': form.init_md5() elif node_id: related_project_node = Node.get_node_instance(node_id) populate_project_form(form, related_project_node) elif dataset_node: project_node = dataset_node.find_child(names.PROJECT) populate_project_form(form, project_node) set_current_page('project') if not node_id: help = [get_help('project'), get_help('project_title')] else: help = [get_help('related_project'), get_help('project_title')] if not node_id: page_title = 'Project' else: page_title = 'Related Project' return render_template('project.html', title=page_title, filename=filename, form=form, help=help)
class TestNode(unittest.TestCase): def setUp(self): self.node = Node(names.EML) def tearDown(self): self.node = None def test_add_attribute(self): self.node.add_attribute('packageId', 'test.1.1') self.node.add_attribute('system', 'metapype') attributes = self.node.attributes for attribute in attributes: self.assertTrue(attribute in ['packageId', 'system']) value = attributes[attribute] self.assertTrue(value in ['test.1.1', 'metapype']) def test_add_child(self): child_1 = Node(names.ACCESS) self.node.add_child(child_1) children = self.node.children self.assertIs(child_1, children[0]) child_2 = Node(names.DATASET) self.node.add_child(child_2, 0) self.assertIs(child_2, children[0]) def test_copy(self): node = Node(names.GIVENNAME) node.content = 'Chase' validate.node(node) node_copy = node.copy() validate.node(node_copy) def test_create_node(self): self.assertIsNotNone(self.node) def test_find_child(self): access = Node(names.ACCESS) self.node.add_child(access) child = self.node.find_child(names.ACCESS) self.assertIs(access, child) allow = Node(names.ALLOW) access.add_child(allow) grandchild = self.node.find_child(names.ALLOW) self.assertIs(grandchild, allow) permission = Node(names.PERMISSION) allow.add_child(permission) great_grandchild = self.node.find_child(names.PERMISSION) self.assertIs(great_grandchild, permission) child = self.node.find_child('nonesuch') self.assertIs(child, None) def test_remove_child(self): access = Node(names.ACCESS) self.node.add_child(access) child = self.node.children[0] self.assertIs(access, child) self.node.remove_child(child) self.assertNotIn(access, self.node.children) def test_replace_child(self): individual_name = Node(names.INDIVIDUALNAME) sur_name_1 = Node(names.SURNAME, parent=individual_name) sur_name_1.content = 'Gaucho' individual_name.add_child(sur_name_1) sur_name_2 = Node(names.SURNAME, parent=individual_name) sur_name_2.content = 'Carroll' self.assertIn(sur_name_1, individual_name.children) self.assertNotIn(sur_name_2, individual_name.children) individual_name.replace_child(old_child=sur_name_1, new_child=sur_name_2) self.assertIn(sur_name_2, individual_name.children) self.assertNotIn(sur_name_1, individual_name.children) # Test for old child removal from node store self.assertNotIn(sur_name_1.id, Node.store) # Test for child node type mismatch given_name = Node(names.GIVENNAME) given_name.content = 'Chase' try: individual_name.replace_child(old_child=sur_name_2, new_child=given_name) except ValueError as e: self.assertIsNotNone(e) def test_shift(self): individual_name_1 = Node(names.INDIVIDUALNAME) individual_name_2 = Node(names.INDIVIDUALNAME) individual_name_3 = Node(names.INDIVIDUALNAME) individual_name_4 = Node(names.INDIVIDUALNAME) organization_name = Node(names.ORGANIZATIONNAME) position_name = Node(names.POSITIONNAME) # Test shift right contact = Node(names.CONTACT) contact.add_child(child=organization_name) contact.add_child(child=individual_name_1) contact.add_child(child=individual_name_2) contact.add_child(child=individual_name_3) contact.add_child(child=position_name) shift_index = contact.shift(child=individual_name_2, direction=Shift.RIGHT) self.assertEqual(shift_index, 3) self.assertIs(contact.children[3], individual_name_2) # Test shift left contact = Node(names.CONTACT) contact.add_child(child=organization_name) contact.add_child(child=individual_name_1) contact.add_child(child=individual_name_2) contact.add_child(child=individual_name_3) contact.add_child(child=position_name) shift_index = contact.shift(child=individual_name_2, direction=Shift.LEFT) self.assertEqual(shift_index, 1) self.assertIs(contact.children[1], individual_name_2) # Test shift on edge right contact = Node(names.CONTACT) contact.add_child(child=organization_name) contact.add_child(child=individual_name_1) contact.add_child(child=individual_name_2) contact.add_child(child=individual_name_3) contact.add_child(child=position_name) index = contact.children.index(individual_name_3) shift_index = contact.shift(child=individual_name_3, direction=Shift.RIGHT) self.assertEqual(index, shift_index) # Test shift on edge left contact = Node(names.CONTACT) contact.add_child(child=organization_name) contact.add_child(child=individual_name_1) contact.add_child(child=individual_name_2) contact.add_child(child=individual_name_3) contact.add_child(child=position_name) index = contact.children.index(individual_name_1) shift_index = contact.shift(child=individual_name_1, direction=Shift.LEFT) self.assertEqual(index, shift_index) # Test hard shift on edge right contact = Node(names.CONTACT) contact.add_child(child=organization_name) contact.add_child(child=individual_name_1) contact.add_child(child=individual_name_2) contact.add_child(child=individual_name_3) index = contact.children.index(individual_name_3) shift_index = contact.shift(child=individual_name_3, direction=Shift.RIGHT) self.assertEqual(index, shift_index) # Test hard shift on edge left contact = Node(names.CONTACT) contact.add_child(child=organization_name) contact.add_child(child=individual_name_1) contact.add_child(child=individual_name_2) contact.add_child(child=individual_name_3) index = contact.children.index(individual_name_1) shift_index = contact.shift(child=individual_name_1, direction=Shift.LEFT) self.assertEqual(index, shift_index) # Test distant sibling shift right contact = Node(names.CONTACT) contact.add_child(child=organization_name) contact.add_child(child=individual_name_1) contact.add_child(child=individual_name_2) contact.add_child(child=individual_name_3) contact.add_child(child=position_name) contact.add_child(child=individual_name_4) shift_index = contact.shift(child=individual_name_3, direction=Shift.RIGHT) index = contact.children.index(individual_name_3) self.assertEqual(index, shift_index) # Test distant sibling shift left contact = Node(names.CONTACT) contact.add_child(child=individual_name_1) contact.add_child(child=organization_name) contact.add_child(child=individual_name_2) contact.add_child(child=individual_name_3) contact.add_child(child=individual_name_4) contact.add_child(child=position_name) shift_index = contact.shift(child=individual_name_2, direction=Shift.LEFT) index = contact.children.index(individual_name_2) self.assertEqual(index, shift_index) def test_get_node(self): access = Node(names.ACCESS) node = Node.get_node_instance(access.id) self.assertIs(access, node) def test_delete_node(self): eml = Node(names.EML) eml.add_attribute('packageId', 'edi.23.1') eml.add_attribute('system', 'metapype') access = Node(names.ACCESS, parent=eml) access.add_attribute('authSystem', 'pasta') access.add_attribute('order', 'allowFirst') eml.add_child(access) allow = Node(names.ALLOW, parent=access) access.add_child(allow) principal = Node(names.PRINCIPAL, parent=allow) principal.content = 'uid=gaucho,o=EDI,dc=edirepository,dc=org' allow.add_child(principal) permission = Node(names.PERMISSION, parent=allow) permission.content = 'all' allow.add_child(permission) node = Node.get_node_instance(principal.id) self.assertIs(principal, node) Node.delete_node_instance(eml.id) self.assertNotIn(principal.id, Node.store) def test_delete_node_no_children(self): eml = Node(names.EML) eml.add_attribute('packageId', 'edi.23.1') eml.add_attribute('system', 'metapype') access = Node(names.ACCESS, parent=eml) access.add_attribute('authSystem', 'pasta') access.add_attribute('order', 'allowFirst') eml.add_child(access) allow = Node(names.ALLOW, parent=access) access.add_child(allow) principal = Node(names.PRINCIPAL, parent=allow) principal.content = 'uid=gaucho,o=EDI,dc=edirepository,dc=org' allow.add_child(principal) permission = Node(names.PERMISSION, parent=allow) permission.content = 'all' allow.add_child(permission) node = Node.get_node_instance(principal.id) self.assertIs(principal, node) Node.delete_node_instance(eml.id, children=False) self.assertIn(principal.id, Node.store)
def taxonomic_coverage(filename=None, node_id=None, taxon=None): form = TaxonomicCoverageForm(filename=filename) # Process POST if request.method == 'POST' and BTN_CANCEL in request.form: url = url_for(PAGE_TAXONOMIC_COVERAGE_SELECT, filename=filename) return redirect(url) if request.method == 'POST' and form.validate_on_submit(): save = False if is_dirty_form(form): save = True # flash(f'save: {save}') form_value = request.form have_links = False if 'Fill' in form_value: source = form.taxonomic_authority.data if source == 'ITIS': source_type = TaxonomySourceEnum.ITIS elif source == 'NCBI': source_type = TaxonomySourceEnum.NCBI elif source == "WORMS": source_type = TaxonomySourceEnum.WORMS try: source_name = '' for choice in form.taxonomic_authority.choices: if choice[0] == source: source_name = choice[1] break hierarchy = fill_taxonomic_coverage(form.taxon_value.data, source_type, source_name) if hierarchy: # set the taxon rank dropdown appropriately rank = hierarchy[0][0].capitalize() if (rank, rank) in form.taxon_rank.choices: form.taxon_rank.data = rank # see if we should display a Links column for taxon in hierarchy: if taxon[4]: have_links = True break except ValueError as e: flash(str(e)) hierarchy = [(form.taxon_rank.data, form.taxon_value.data, '', '')] form.hierarchy.data = hierarchy form.hidden_taxon_rank.data = form.taxon_rank.data form.hidden_taxon_value.data = form.taxon_value.data form.hidden_taxonomic_authority.data = form.taxonomic_authority.data help = get_helps(['taxonomic_coverage_fill_hierarchy']) return render_template( 'taxonomic_coverage.html', title='Taxonomic Coverage', form=form, hierarchy=hierarchy, taxon_rank=form.taxon_rank.data, taxon_value=form.taxon_value.data, taxonomic_authority=form.taxonomic_authority.data, help=help, have_links=have_links) form_dict = form_value.to_dict(flat=False) new_page = PAGE_TAXONOMIC_COVERAGE_SELECT if form_dict: for key in form_dict: val = form_dict[key][0] # value is the first list element if val == BTN_HIDDEN_NEW: new_page = PAGE_CREATE break elif val == BTN_HIDDEN_OPEN: new_page = PAGE_OPEN break elif val == BTN_HIDDEN_CLOSE: new_page = PAGE_CLOSE break if save: if not form.taxon_value.data and not form.taxon_rank.data: return redirect(url_for(new_page, filename=filename)) submitted_hierarchy = form_value.get('hierarchy') if isinstance(form_value.get('hierarchy'), str) and form_value.get('hierarchy'): # convert hierarchy string to list submitted_hierarchy = ast.literal_eval( form_value.get('hierarchy')) form.hierarchy.data = submitted_hierarchy # if we're saving after doing 'Fill Hierarchy', fill in the values we've been passed if form_value.get('hidden_taxon_rank'): form.taxon_rank.data = form_value.get('hidden_taxon_rank') form.taxon_value.data = form_value.get('hidden_taxon_value') form.taxonomic_authority.data = form_value.get( 'hidden_taxonomic_authority') elif not submitted_hierarchy: # we don't have a hierarchy, so construct a fake hierarchy to be used by create_taxonomic_coverage() form.hierarchy.data = [(form_value.get('taxon_rank'), form_value.get('taxon_value'), '', '', '', '')] if not form_value.get('taxon_rank'): flash('Taxon Rank is required.') return redirect( url_for(PAGE_TAXONOMIC_COVERAGE, filename=filename, node_id=node_id, taxon=form.taxon_value.data)) eml_node = load_eml(filename=filename) dataset_node = eml_node.find_child(names.DATASET) if not dataset_node: dataset_node = Node(names.DATASET) coverage_node = dataset_node.find_child(names.COVERAGE) if not coverage_node: coverage_node = Node(names.COVERAGE, parent=dataset_node) add_child(dataset_node, coverage_node) txc_node = Node(names.TAXONOMICCOVERAGE, parent=coverage_node) create_taxonomic_coverage(txc_node, form.general_taxonomic_coverage.data, form.hierarchy.data, form.taxonomic_authority.data) if node_id and len(node_id) != 1: old_txc_node = Node.get_node_instance(node_id) if old_txc_node: coverage_parent_node = old_txc_node.parent coverage_parent_node.replace_child(old_txc_node, txc_node) else: msg = f"No node found in the node store with node id {node_id}" raise Exception(msg) else: add_child(coverage_node, txc_node) save_both_formats(filename=filename, eml_node=eml_node) return redirect(url_for(new_page, filename=filename)) # Process GET have_links = False if node_id == '1': form.init_md5() if taxon: form.taxon_value.data = taxon else: eml_node = load_eml(filename=filename) dataset_node = eml_node.find_child(names.DATASET) if dataset_node: coverage_node = dataset_node.find_child(names.COVERAGE) if coverage_node: txc_nodes = coverage_node.find_all_children( names.TAXONOMICCOVERAGE) if txc_nodes: for txc_node in txc_nodes: if node_id == txc_node.id: have_links = populate_taxonomic_coverage_form( form, txc_node) help = get_helps(['taxonomic_coverage_fill_hierarchy']) set_current_page('taxonomic_coverage') return render_template('taxonomic_coverage.html', title='Taxonomic Coverage', form=form, hierarchy=form.hierarchy.data, have_links=have_links, help=help)
def populate_responsible_party_form(form: ResponsiblePartyForm, node: Node): in_node = node.find_child(names.INDIVIDUALNAME) if in_node: salutation_node = in_node.find_child(names.SALUTATION) if salutation_node: form.salutation.data = salutation_node.content gn_nodes = in_node.find_all_children(names.GIVENNAME) if gn_nodes: form.gn.data = gn_nodes[0].content if len(gn_nodes) > 1: form.mn.data = gn_nodes[1].content sn_node = in_node.find_child(names.SURNAME) if sn_node: form.sn.data = sn_node.content user_id_node = node.find_child(names.USERID) if user_id_node: form.user_id.data = user_id_node.content organization_node = node.find_child(names.ORGANIZATIONNAME) if organization_node: form.organization.data = organization_node.content position_name_node = node.find_child(names.POSITIONNAME) if position_name_node: form.position_name.data = position_name_node.content address_node = node.find_child(names.ADDRESS) if address_node: delivery_point_nodes = \ address_node.find_all_children(names.DELIVERYPOINT) if len(delivery_point_nodes) > 0: form.address_1.data = delivery_point_nodes[0].content if len(delivery_point_nodes) > 1: form.address_2.data = delivery_point_nodes[1].content city_node = address_node.find_child(names.CITY) if city_node: form.city.data = city_node.content administrative_area_node = \ address_node.find_child(names.ADMINISTRATIVEAREA) if administrative_area_node: form.state.data = administrative_area_node.content postal_code_node = address_node.find_child(names.POSTALCODE) if postal_code_node: form.postal_code.data = postal_code_node.content country_node = address_node.find_child(names.COUNTRY) if country_node: form.country.data = country_node.content phone_node = node.find_child(names.PHONE) if phone_node: form.phone.data = phone_node.content phone_nodes = node.find_all_children(names.PHONE) for phone_node in phone_nodes: phone_type = phone_node.attribute_value('phonetype') if phone_type == 'facsimile': form.fax.data = phone_node.content else: form.phone.data = phone_node.content email_node = node.find_child(names.ELECTRONICMAILADDRESS) if email_node: form.email.data = email_node.content online_url_node = node.find_child(names.ONLINEURL) if online_url_node: form.online_url.data = online_url_node.content role_node = node.find_child(names.ROLE) if role_node: form.role.data = role_node.content form.md5.data = form_md5(form)
def check_attribute(eml_node, doc_name, data_table_node: Node, attrib_node: Node): attr_type = get_attribute_type(attrib_node) mscale = None page = None if attr_type == metapype_client.VariableType.CATEGORICAL: page = PAGE_ATTRIBUTE_CATEGORICAL mscale = metapype_client.VariableType.CATEGORICAL.name data_table_name = None if data_table_node: data_table_name = data_table_node.find_child( names.ENTITYNAME).content attrib_name = None if attrib_node: attrib_name_node = attrib_node.find_child(names.ATTRIBUTENAME) if attrib_name_node: attrib_name = attrib_name_node.content # log_info(f"CATEGORICAL... filename={filename} data_table={data_table_name} attr_name={attrib_name} attr_type={attr_type}") elif attr_type == metapype_client.VariableType.NUMERICAL: page = PAGE_ATTRIBUTE_NUMERICAL mscale = metapype_client.VariableType.NUMERICAL.name elif attr_type == metapype_client.VariableType.TEXT: page = PAGE_ATTRIBUTE_TEXT mscale = metapype_client.VariableType.TEXT.name elif attr_type == metapype_client.VariableType.DATETIME: page = PAGE_ATTRIBUTE_DATETIME mscale = metapype_client.VariableType.DATETIME.name # This section is temporary code to track down a bug if not page: data_table_name = None if data_table_node: data_table_name = data_table_node.find_child( names.ENTITYNAME).content attrib_name = None if attrib_node: attrib_name_node = attrib_node.find_child(names.ATTRIBUTENAME) if attrib_name_node: attrib_name = attrib_name_node.content log_error( f"page not initialized... filename={doc_name} data_table={data_table_name} attr_name={attrib_name} attr_type={attr_type}" ) return link = url_for(page, filename=doc_name, dt_node_id=data_table_node.id, node_id=attrib_node.id, mscale=mscale) validation_errs = validate_via_metapype(attrib_node) if find_content_empty(validation_errs, names.ATTRIBUTEDEFINITION): add_to_evaluation('attributes_01', link) if find_min_unmet(validation_errs, names.MISSINGVALUECODE, names.CODEEXPLANATION): add_to_evaluation('attributes_07', link) # Categorical if attr_type == metapype_client.VariableType.CATEGORICAL: if find_min_unmet(validation_errs, names.ENUMERATEDDOMAIN, names.CODEDEFINITION): add_to_evaluation('attributes_04', link) found = find_content_empty(validation_errs, names.CODE) if found: generate_code_definition_errs(eml_node, doc_name, 'attributes_05', found) found = find_content_empty(validation_errs, names.DEFINITION) if found: generate_code_definition_errs(eml_node, doc_name, 'attributes_06', found) # Numerical if attr_type == metapype_client.VariableType.NUMERICAL: if find_min_unmet(validation_errs, names.RATIO, names.UNIT): add_to_evaluation('attributes_02', link) if find_min_unmet_for_choice(validation_errs, names.UNIT): add_to_evaluation('attributes_02', link) # DateTime if attr_type == metapype_client.VariableType.DATETIME: if find_content_empty(validation_errs, names.FORMATSTRING): add_to_evaluation('attributes_03', link)
def maintenance(filename=None): form = MaintenanceForm(filename=filename) eml_node = load_eml(filename=filename) if eml_node: dataset_node = eml_node.find_child(names.DATASET) if not dataset_node: dataset_node = Node(names.DATASET, parent=eml_node) add_child(eml_node, dataset_node) # Process POST if request.method == 'POST' and form.validate_on_submit(): save = False if is_dirty_form(form): save = True # flash(f'save: {save}') if save: description = add_paragraph_tags(form.description.data) update_frequency = form.update_frequency.data create_maintenance(dataset_node, description, update_frequency) save_both_formats(filename=filename, eml_node=eml_node) form_value = request.form form_dict = form_value.to_dict(flat=False) if form_dict: for key in form_dict: val = form_dict[key][0] # value is the first list element if val == BTN_SAVE_AND_CONTINUE: new_page = PAGE_PUBLISHER elif val == BTN_HIDDEN_CHECK: new_page = PAGE_CHECK elif val == BTN_HIDDEN_SAVE: new_page = PAGE_PROJECT elif val == BTN_HIDDEN_DOWNLOAD: new_page = PAGE_DOWNLOAD elif val == BTN_HIDDEN_NEW: new_page = PAGE_CREATE elif val == BTN_HIDDEN_OPEN: new_page = PAGE_OPEN elif val == BTN_HIDDEN_CLOSE: new_page = PAGE_CLOSE return redirect(url_for(new_page, filename=filename)) # Process GET if dataset_node: maintenance_node = dataset_node.find_child(names.MAINTENANCE) if maintenance_node: populate_maintenance_form(form, maintenance_node) set_current_page('maintenance') help = [ get_help('maintenance'), get_help('maintenance_description'), get_help('maintenance_freq') ] return render_template('maintenance.html', title='Maintenance', filename=filename, form=form, help=help)
def keyword(filename=None, node_id=None): eml_node = load_eml(filename=filename) dataset_node = eml_node.find_child(names.DATASET) if not dataset_node: dataset_node = Node(names.DATASET, parent=eml_node) add_child(eml_node, dataset_node) form = KeywordForm(filename=filename, node_id=node_id) form.init_keywords() # Process POST if request.method == 'POST' and BTN_CANCEL in request.form: url = url_for(PAGE_KEYWORD_SELECT, filename=filename) return redirect(url) # if request.method == 'POST' and form.validate_on_submit(): if request.method == 'POST': form_value = request.form form_dict = form_value.to_dict(flat=False) new_page = PAGE_KEYWORD_SELECT if form_dict: for key in form_dict: val = form_dict[key][0] # value is the first list element new_page = check_val_for_hidden_buttons( val, new_page, new_page) submit_type = None if is_dirty_form(form): submit_type = 'Save Changes' # flash(f'submit_type: {submit_type}') if submit_type == 'Save Changes': keyword = form.keyword.data keyword_type = form.keyword_type.data keyword_thesaurus = form.keyword_thesaurus.data # If so thesaurus was specified, see if the LTER Controlled Vocabulary applies if not keyword_thesaurus: lter_keywords = get_keywords('LTER') if keyword in lter_keywords: keyword_thesaurus = 'LTER Controlled Vocabulary' keyword_set_nodes = [] eml_node.find_all_descendants(names.KEYWORDSET, keyword_set_nodes) keyword_set_node = None for kws_node in keyword_set_nodes: keyword_thesaurus_node = kws_node.find_child( names.KEYWORDTHESAURUS) if keyword_thesaurus_node and keyword_thesaurus_node.content == keyword_thesaurus: keyword_set_node = kws_node break if not keyword_thesaurus_node and not keyword_thesaurus: keyword_set_node = kws_node break if not keyword_set_node: keyword_set_node = Node(names.KEYWORDSET, parent=dataset_node) add_child(dataset_node, keyword_set_node) if keyword_thesaurus: keyword_thesaurus_node = Node(names.KEYWORDTHESAURUS, parent=keyword_set_node) keyword_thesaurus_node.content = keyword_thesaurus keyword_set_node.children.append(keyword_thesaurus_node) keyword_node = Node(names.KEYWORD, parent=keyword_set_node) create_keyword(keyword_node, keyword, keyword_type) if node_id and len(node_id) != 1: old_keyword_node = Node.get_node_instance(node_id) if old_keyword_node: keyword_parent_node = old_keyword_node.parent keyword_parent_node.replace_child(old_keyword_node, keyword_node) else: msg = f"No keyword node found in the node store with node id {node_id}" raise Exception(msg) else: add_child(keyword_set_node, keyword_node) save_both_formats(filename=filename, eml_node=eml_node) url = url_for(new_page, filename=filename) return redirect(url) # Process GET if node_id == '1': form.init_md5() else: keyword_set_nodes = [] eml_node.find_all_descendants(names.KEYWORDSET, keyword_set_nodes) found = False for keyword_set_node in keyword_set_nodes: keyword_nodes = keyword_set_node.find_all_children(names.KEYWORD) keyword_thesaurus_node = keyword_set_node.find_child( names.KEYWORDTHESAURUS) if keyword_nodes: for kw_node in keyword_nodes: if node_id == kw_node.id: populate_keyword_form(form, kw_node, keyword_thesaurus_node) found = True break if found: break set_current_page('keyword') help = [get_help('keywords')] return render_template('keyword.html', title='Keyword', form=form, filename=filename, help=help)