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)