def migrate_meta():
from app.models import User, Role, Permission, \
IUCNStatus, OrganismType, GrowthFormRaunkiaer, ReproductiveRepetition, \
DicotMonoc, AngioGymno, SpandExGrowthType, SourceType, Database, Purpose, MissingData, ContentEmail, Ecoregion, Continent, InvasiveStatusStudy, InvasiveStatusElsewhere, StageTypeClass, \
TransitionType, MatrixComposition, StartSeason, StudiedSex, Captivity, Species, Taxonomy, Trait, \
Publication, AuthorContact, AdditionalSource, Population, Stage, StageType, Treatment, \
MatrixStage, MatrixValue, Matrix, Interval, Fixed, Small, CensusTiming, PurposeEndangered, PurposeWeed, Institute, Version, \
PublicationsProtocol, DigitizationProtocol, Protocol, CommonTerm
print "Migrating Meta Tables..."
Role.insert_roles()
Species.migrate()
Taxonomy.migrate()
Trait.migrate()
Publication.migrate()
AuthorContact.migrate()
Population.migrate()
StageType.migrate()
MatrixValue.migrate()
Matrix.migrate()
Fixed.migrate()
Version.migrate()
Institute.migrate()
User.migrate()
Database.migrate()
Status.migrate()
PublicationsProtocol.migrate()
DigitizationProtocol.migrate()
CommonTerm.migrate()
return
def hello_world():
v = Version()
v.version = '0.4'
v.latest = True
db.session.add(v)
db.session.commit()
return v.version
def hello_world():
v = Version()
v.version = '0.4'
v.latest = True
db.session.add(v)
db.session.commit()
return v.version
def migrate_meta():
from app.models import User, Role, Permission, \
IUCNStatus, ESAStatus, OrganismType, GrowthFormRaunkiaer, ReproductiveRepetition, \
DicotMonoc, AngioGymno, SpandExGrowthType, SourceType, Database, Purpose, MissingData, ContentEmail, Ecoregion, Continent, InvasiveStatusStudy, InvasiveStatusElsewhere, StageTypeClass, \
TransitionType, MatrixComposition, StartSeason, StudiedSex, Captivity, Species, Taxonomy, Trait, \
Publication, Study, AuthorContact, AdditionalSource, Population, Stage, StageType, Treatment, \
MatrixStage, MatrixValue, Matrix, Interval, Fixed, Small, CensusTiming, PurposeEndangered, PurposeWeed, Institute
print "Migrating Meta Tables..."
try:
Role.insert_roles()
Species.migrate()
Taxonomy.migrate()
Trait.migrate()
Publication.migrate()
AuthorContact.migrate()
Population.migrate()
StageType.migrate()
MatrixValue.migrate()
Matrix.migrate()
Fixed.migrate()
Study.migrate()
User.migrate()
Version.migrate()
Institute.migrate()
except:
"Error migrating metadata"
finally:
"Done + good"
return
def uploadTrackVersion(artistId, projectId, trackId):
'''
Posts a new mix version to AWS [X]
Updates on database [X]
Updates on AWS [X]
'''
user = current_user
artist = User.query.get(artistId)
project = Project.query.get(projectId)
track = Track.query.get(trackId)
if user.superUser:
if track:
if track.projectId == project.id:
if project.artistId == artist.id:
if project.engineerId == user.id:
if "file" not in request.files:
return {"errors": "file required"}, 400
file = request.files["file"]
if not allowed_file(file.filename):
return {"errors": "file type not permitted"}, 400
file.filename = get_unique_filename(file.filename)
upload = upload_file_to_s3(file)
db.session.flush()
if "url" not in upload:
return upload, 400
url = upload["url"]
data = Version(url=upload["url"],
length=3,
trackId=track.id)
db.session.add(data)
db.session.commit()
return data.to_dict()
else:
return {
"Errors":
f"{user.firstName} {user.lastName} cannot delete '{project.name}' because they are not on the project"
} # noqa
else:
return {
"Errors":
f"'{project.name}' does not belong to {artist.firstName} {artist.lastName}"
} # noqa
else:
return {
"Errors":
f"'{track.name}' does not belong to {project.name}"
} # noqa
else:
return {"Errors": f"Track does not exist!"}
else:
return {
"Errors":
f"{user.firstName} {user.lastName} is not authorized to perform this action."
} # noqa
def test_get_version(self):
Version.new_version('0.0.1', 'https://bllli.cn:2345/download',
u'项目正式开启内测 欢迎使用测试')
Version.new_version('0.0.2', 'https://bllli.cn:2345/download',
u'新增教师登录功能')
response = self.client.get(url_for('api.get_new_version'),
headers=get_api_headers('bllli', 'cat'))
self.assertTrue(response.status_code == 200)
response_json = json.loads(response.data.decode('utf-8'))
self.assertIsNotNone(response_json)
self.assertEqual(response_json.get('download_android'),
'https://bllli.cn:2345/download')
self.assertEqual(
response_json.get('download_qr_url'),
'http://qr.topscan.com/api.php?'
'text=%s&logo=http://otl5stjju.bkt.clouddn.com/logo.png' %
'https://bllli.cn:2345/download')
self.assertEqual(response_json.get('version'), '0.0.2')
self.assertEqual(response_json.get('whatsnew'), '新增教师登录功能')
def createdb():
""" Creates a database with all of the tables defined in
your SQLAlchemy models
"""
db.create_all()
# Version and User added manually at DB creation (this is used only for the skeleton example)
v = Version()
v.version = '0.1'
v.latest = True
db.session.add(v)
u = User()
u.name = 'Tiago Reichert'
u.email = '*****@*****.**'
db.session.add(u)
u = User()
u.name = 'Foo Bar'
u.email = '*****@*****.**'
db.session.add(u)
db.session.commit()
def versions(id, version_id):
if request.method == 'GET':
result = version_schema.dump(Version.query.get(version_id))
return jsonify(result)
elif request.method == 'POST':
version = Version(id=version_id, application_id=id)
db.session.add(version)
db.session.commit()
versions = Version.query.all()
result = versions_schema.dump(versions)
print(999)
return jsonify(result)
def __init__(self):
self.data = {
"mbs": {
"eq_id":
"mbs",
"form_type":
"0001",
"created_by":
"Samiwel Thomas",
"created_at":
str(datetime.utcnow()),
"versions": [
Version("1", "0001", {"hello": "world"}, "a Thomas", "en",
None, None),
Version("2", "0001", {}, "b Thomas", "en", None, None),
Version("3", "0001", {}, "c Thomas", "en", None, None),
Version("4", "0001", {}, "d Thomas", "en", None, None),
],
},
"qpses": {
"eq_id":
"qpses",
"form_type":
"0169",
"created_by":
"Samiwel Thomas",
"created_at":
str(datetime.utcnow()),
"versions": [
Version("1", "0169", {}, "a Thomas", "en", None, None),
Version("2", "0169", {}, "b Thomas", "en", None, None),
Version("3", "0169", {}, "c Thomas", "en", None, None),
Version("4", "0169", {}, "d Thomas", "en", None, None),
],
},
}
remove_dup(size2),
remove_dup(nom),
remove_dup(noc),
remove_dup(wmc),
remove_dup(rfc),
remove_dup(dit),
remove_dup(cbo),
remove_dup(ce),
remove_dup(ca),
remove_dup(lcom),
],
axis=1)
df.fillna(1, inplace=True)
df.to_excel(f'./ValidationResults/{project_name}.xlsx',
sheet_name='code quality and metrics')
excel_writer = pd.ExcelWriter(f'./ValidationResults/{project_name}.xlsx',
engine='openpyxl')
add_sheet(calc_corr('maintainability', df), excel_writer,
'maintainability')
return df
if __name__ == '__main__':
project = Project('alibaba/metrics', '', 'mongo')
version = Version(project, 'metrics-2.0.6', '', '', '')
cs = CodeScanner(version)
cs.scan()
cq_validate(version.version_scan_results_dir, 'metrics')
def submit_new(data):
import datetime
version = {
'checked': True,
'checked_count': 1,
'statuses': Status.query.filter_by(status_name="Green").first()
}
if data["population_database_id"] == "XXX" or data[
"population_database_id"] == "X.X.X":
version = {
'checked': False,
'checked_count': 0,
'statuses': Status.query.filter_by(status_name="Pending").first()
}
# When checking for null data later, these need to be excluded, as they will always have a value
ignore_keys = ['version_ok', 'version_latest', 'version_original']
''' DigitizationProtocol '''
# digitization_protocol = DigitizationProtocol.query.filter_by(field_name=data["digitization_protocol"]).first()
# if digitization_protocol == None:
# ac_dict = {'protocol_id' : protocol.id,
# 'field_name' : data['field_name'],
# 'name_in_csv' : data["name_in_csv"],
# 'database_model' : data["database_model"],
# 'field_description' : data["field_description"],
# 'field_short_description' : data["field_short_description"]
# }
# ac_cleaned = data_clean(ac_dict)
# digitization_protocol = Protocol(**ac_cleaned["kwargs"])
# db.session.add(digitization_protocol)
# db.session.commit()
''' Publication '''
publications_protocol = PublicationsProtocol.query.filter_by(
protocol_number=data["publications_protocol_id"]).first()
if data["publication_DOI_ISBN"] == None:
publication = Publication.query.filter_by(
authors=data["publication_authors"]
).filter_by(year=data["publication_year"]).filter_by(
journal_name=data["publication_journal_name"]).filter_by(
additional_source_string=data[
"publication_additional_source_string"]).filter_by(
study_notes=data["publication_study_notes"]).first()
else:
publication = Publication.query.filter_by(
DOI_ISBN=data["publication_DOI_ISBN"]).first()
if publication == None:
purposes = {
"Comparative Demography":
data["publication_purpose_comparative_demography"],
"Spatial Demography":
data["publication_purpose_spatial_demography"],
"Abiotic Impacts":
data["publication_purpose_abiotic"],
"PVA":
data["publication_purpose_pva"],
"Species Dynamics Description":
data["publication_purpose_species_dynamics_description"],
"Interspecific Interactions":
data["publication_purpose_interspecific_interactions"],
"Management Evaluation":
data["publication_purpose_management_evaluation"],
"Methodological Advancement":
data["publication_purpose_methodological_advancement"]
}
queryset = [
Purpose.query.filter(Purpose.purpose_name == key).first()
for key, val in purposes.items() if val == '1'
]
if data['publication_missing_data'] != 'NDY' and data[
'publication_missing_data']:
missing_data_unicode = data['publication_missing_data'].replace(
" ", "").split(';')
missing_data = [
MissingData.query.filter_by(missing_code=key).first()
for key in missing_data_unicode
if MissingData.query.filter_by(missing_code=key).first()
]
else:
missing_data = 'NDY'
pub_dict = {
'authors':
data["publication_authors"],
'year':
data["publication_year"],
'publications_protocol':
publications_protocol,
'DOI_ISBN':
data["publication_DOI_ISBN"],
'additional_source_string':
data["publication_additional_source_string"],
'journal_name':
data["publication_journal_name"],
'date_digitised':
datetime.datetime.strptime(data['publication_date_digitization'],
"%d/%m/%Y").strftime("%Y-%m-%d")
if data['publication_date_digitization'] else None,
'purposes':
queryset,
'study_notes':
data["publication_study_notes"]
}
pub_cleaned = data_clean(pub_dict)
# if not all(value == None for key, value in pub_cleaned["kwargs"].items() if key not in ignore_keys) and study_present:
publication = Publication(**pub_cleaned["kwargs"])
db.session.add(publication)
db.session.commit()
publication.missing_data = missing_data if type(
missing_data) == list else []
db.session.add(publication)
db.session.commit()
''' Publication Version '''
#version = version_data(pub_cleaned)
publication_version = Version(**version)
publication_version.publication = publication
publication.colour = gen_hex_code()
possible_user = User.query.filter_by(
name=data["publication_student"]).first()
na_user = User.query.filter_by(name="N/A").first()
if possible_user == None:
possible_user = na_user
publication_version.entered_by_id = possible_user.id if possible_user else None,
publication_version.checked_by_id = na_user.id if na_user else None,
db.session.add(publication_version)
db.session.commit()
publication_version.original_version_id = publication_version.id
db.session.add(publication_version)
db.session.commit()
''' Author contact '''
author_contacts = AuthorContact.query.filter_by(
corresponding_author=data["publication_corresponding_author"]
).filter_by(
corresponding_author_email=data["publication_corresponding_email"]
).first()
if author_contacts == None:
ac_dict = {
'publication_id':
publication.id,
'date_contacted':
datetime.datetime.strptime(data['date_author_contacted'],
"%d/%m/%Y").strftime("%Y-%m-%d")
if data['date_author_contacted'] else None,
'date_contacted_again':
datetime.datetime.strptime(data['date_author_contacted_again'],
"%d/%m/%Y").strftime("%Y-%m-%d")
if data['date_author_contacted_again'] else None,
'extra_content_email':
data["correspondence_email_content"],
'author_reply':
data["correspondence_author_reply"],
'corresponding_author':
data["publication_corresponding_author"],
'corresponding_author_email':
data["publication_corresponding_email"],
'correspondence_email_content':
data["correspondence_email_content"],
'extra_content_email':
data["extra_content_email"],
'contacting_user_id':
possible_user.id if possible_user else None
}
ac_cleaned = data_clean(ac_dict)
author_contact = AuthorContact(**ac_cleaned["kwargs"])
db.session.add(author_contact)
db.session.commit()
''' Author Contact Version '''
#version = version_data(ac_cleaned)
author_contact_version = Version(**version)
author_contact_version.author_contact = author_contact
db.session.add(author_contact_version)
db.session.commit()
author_contact_version.original_version_id = author_contact_version.id
db.session.add(author_contact_version)
db.session.commit()
''' Species '''
species = Species.query.filter_by(
species_accepted=data["species_accepted"]).first()
iucn = IUCNStatus.query.filter_by(
status_code=data["species_iucn_status_id"]).first()
if species == None:
species_dict = {
'gbif_taxon_key': data["species_gbif_taxon_key"],
'species_iucn_taxonid': data["species_iucn_taxonid"],
'species_accepted': data["species_accepted"],
'species_common': data["species_common"],
'iucn_status_id': iucn.id if iucn else None,
'image_path': data["image_path"],
'image_path2': data["image_path2"]
}
species_cleaned = data_clean(species_dict)
species = Species(**species_cleaned["kwargs"])
db.session.add(species)
db.session.commit()
''' Species Version '''
#version = version_data(species_cleaned)
species_version = Version(**version)
species_version.species = species
db.session.add(species_version)
db.session.commit()
species_version.original_version_id = species_version.id
db.session.add(species_version)
db.session.commit()
''' Trait '''
spand_ex_growth_type = SpandExGrowthType.query.filter_by(
type_name=data["trait_spand_ex_growth_type_id"]).first()
dicot_monoc = DicotMonoc.query.filter_by(
dicot_monoc_name=data["trait_dicot_monoc_id"]).first()
growth_form_raunkiaer = GrowthFormRaunkiaer.query.filter_by(
form_name=data["trait_growth_form_raunkiaer_id"]).first()
organism_type = OrganismType.query.filter_by(
type_name=data["trait_organism_type_id"]).first()
angio_gymno = AngioGymno.query.filter_by(
angio_gymno_name=data["trait_angio_gymno_id"]).first()
trait = Trait.query.filter_by(species_id=species.id).first()
if trait == None:
trait_dict = {
'species_id':
species.id,
'organism_type':
organism_type,
'dicot_monoc':
dicot_monoc,
'angio_gymno':
angio_gymno,
'species_seedbank':
coerce_boolean(data["species_seedbank"]),
'species_gisd_status':
coerce_boolean(data["species_gisd_status"]),
'species_clonality':
coerce_boolean(data["species_clonality"]),
'spand_ex_growth_type_id':
spand_ex_growth_type.id if spand_ex_growth_type else None,
'growth_form_raunkiaer_id':
growth_form_raunkiaer.id if growth_form_raunkiaer else None
}
trait_cleaned = data_clean(trait_dict)
trait = Trait(**trait_cleaned["kwargs"])
db.session.add(trait)
db.session.commit()
''' Trait Version '''
#version = version_data(trait_cleaned)
trait_version = Version(**version)
trait_version.trait = trait
db.session.add(trait_version)
db.session.commit()
trait_version.original_version_id = trait_version.id
db.session.add(trait_version)
db.session.commit()
''' Taxonomy '''
tax = Taxonomy.query.filter_by(species_id=species.id).first()
if tax == None:
tax_dict = {
'authority':
None,
'tpl_version':
None,
'infraspecies_accepted':
None,
'species_epithet_accepted':
None,
'genus_accepted':
data["taxonomy_genus_accepted"],
'genus':
data["taxonomy_genus"],
'family':
data["taxonomy_family"],
'tax_order':
data["taxonomy_order"],
'tax_class':
data["taxonomy_class"],
'phylum':
data["taxonomy_phylum"],
'kingdom':
data["taxonomy_kingdom"],
'col_check_date':
datetime.datetime.strptime(data["taxonomy_col_check_date"],
"%d/%m/%Y").strftime("%Y-%m-%d")
if data['taxonomy_col_check_date'] else None,
'col_check_ok':
coerce_boolean(data["taxonomy_col_check_ok"])
}
tax_cleaned = data_clean(tax_dict)
# if not all(value == None for key, value in tax_cleaned["kwargs"].items() if key not in ignore_keys):
tax = Taxonomy(**tax_cleaned["kwargs"])
db.session.add(tax)
db.session.commit()
tax.species = species
db.session.add(tax)
db.session.commit()
''' Taxonomy Version '''
#version = version_data(tax_cleaned)
taxonomy_version = Version(**version)
taxonomy_version.version_number = 1
taxonomy_version.taxonomy = tax
db.session.add(taxonomy_version)
db.session.commit()
taxonomy_version.original_version_id = taxonomy_version.id
db.session.add(taxonomy_version)
db.session.commit()
''' Study '''
# What if all none? Will they be grouped together?
# study = Study.query.filter_by(publication_id=publication.id, study_start=data["study_start"], study_end=data["study_end"]).first()
# if study == None:
# purpose_endangered = PurposeEndangered.query.filter_by(purpose_name=data["study_purpose_endangered_id"]).first() if data["study_purpose_endangered_id"] else data["study_purpose_endangered_id"]
#
# purpose_weed = PurposeWeed.query.filter_by(purpose_name="study_purpose_weed_id").first() if data["study_purpose_weed_id"] else data["study_purpose_weed_id"]
# database_source = Institute.query.filter_by(institution_name=data["study_database_source"]).first()# if data["study_purpose_weed_id"] else data["study_purpose_endangered_id"]
#
# study_dict = {'study_duration' : data["study_duration"],
# 'study_start' : data["study_start"],
# 'study_end' : data["study_end"],
# 'number_populations' : data["study_number_populations"],
# 'purpose_endangered_id' : purpose_endangered.id if purpose_endangered else None,
# 'purpose_weed_id' : purpose_weed.id if purpose_weed else None,
# 'database_source' : database_source}
#
# study_cleaned = data_clean(study_dict)
#
# # if not all(value == None for key, value in study_cleaned["kwargs"].items() if key not in ignore_keys) and population_present:
# study = Study(**study_cleaned["kwargs"])
# db.session.add(study)
# db.session.commit()
#
# study.publication_id = publication.id
# study.species_id = species.id
# db.session.add(study)
# db.session.commit()
#
#
# ''' Study Version '''
# version = version_data(study_cleaned)
# study_version = Version(**version)
# study_version.version_number = 1
# study_version.study = study
# db.session.add(study_version)
# db.session.commit()
# study_version.original_version_id = study_version.id
# db.session.add(study_version)
# db.session.commit()
''' Protocol '''
# digitization_protocol = DigitizationProtocol.query.filter_by(field_name=data["digitization_protocol_id"]).first()
# commonterm = CommonTerm.query.filter_by(common_value_name=data["commonterm_id"]).first()
# protocol = Protocol.query.filter_by(protocol_id=protocol.id).first()
# if protocol == None:
# protocol_dict = {'protocol_id' : protocol.id,
# 'digitization_protocol_id' : digitization_protocol.id if digitization_protocol else None,
# 'commonterm_id' : commonterm.id if commonterm else None}
# protocol_cleaned = data_clean(protocol_dict)
# protocol = Protocol(**protocol_cleaned["kwargs"])
# db.session.add(protocol)
# db.session.commit()
''' Population '''
''' '''
invasive_status_study = InvasiveStatusStudy.query.filter_by(
status_name=data["population_invasive_status_study_id"]).first()
invasive_status_elsewhere = InvasiveStatusStudy.query.filter_by(
status_name=data["population_invasive_status_elsewhere_id"]).first()
ecoregion = Ecoregion.query.filter_by(
ecoregion_code=data["population_ecoregion_id"]).first()
continent = Continent.query.filter_by(
continent_name=data["population_continent_id"]).first()
###Danny trying add database meta-table in correct location
database = Database.query.filter_by(
database_master_version=data["population_database_id"]).first()
purpose_endangered = PurposeEndangered.query.filter_by(
purpose_name=data["study_purpose_endangered_id"]).first(
) if data["study_purpose_endangered_id"] else data[
"study_purpose_endangered_id"]
purpose_weed = PurposeWeed.query.filter_by(
purpose_name="study_purpose_weed_id").first(
) if data["study_purpose_weed_id"] else data["study_purpose_weed_id"]
database_source = Institute.query.filter_by(
institution_name=data["study_database_source_id"]).first()
pop = Population.query.filter_by(population_name=data["population_name"],
publication_id=publication.id,
species_id=species.id).first()
if pop == None:
pop_dict = {
'population_name':
data["population_name"],
'latitude':
data["population_latitude"],
'lat_ns':
data["lat_ns"],
'lat_deg':
data["lat_deg"],
'lat_min':
data["lat_min"],
'lat_sec':
data["lat_sec"],
'longitude':
data["population_longitude"],
'lon_ew':
data["lon_ew"],
'lon_deg':
data["lon_deg"],
'lon_min':
data["lon_min"],
'lon_sec':
data["lon_sec"],
'altitude':
data["population_altitude"],
#'pop_size' : data["population_pop_size"],
'country':
data["population_country"],
'invasive_status_study_id':
invasive_status_study.id if invasive_status_study else None,
'invasive_status_elsewhere_id':
invasive_status_elsewhere.id
if invasive_status_elsewhere else None,
'ecoregion':
ecoregion,
'continent':
continent,
'database':
database,
'within_site_replication':
data['population_within_site_replication'],
'study_duration':
data["study_duration"],
'study_start':
data["study_start"],
'study_end':
data["study_end"],
'number_populations':
data["study_number_populations"],
'purpose_endangered_id':
purpose_endangered.id if purpose_endangered else None,
'purpose_weed_id':
purpose_weed.id if purpose_weed else None,
'database_source':
database_source
}
pop_cleaned = data_clean(pop_dict)
# if not all(value == None for key, value in pop_cleaned["kwargs"].items() if key not in ignore_keys) and matrix_present:
pop = Population(**pop_cleaned["kwargs"])
db.session.add(pop)
db.session.commit()
pop.species_author = data["species_author"]
pop.publication_id = publication.id
pop.species_id = species.id
db.session.add(pop)
db.session.commit()
''' Population Version '''
#version = version_data(pop_cleaned)
population_version = Version(**version)
population_version.version_number = 1
population_version.population = pop
db.session.add(population_version)
db.session.commit()
population_version.original_version_id = population_version.id
db.session.add(population_version)
db.session.commit()
''' Matrix '''
treatment_string = data["matrix_treatment_id"]
if treatment_string == 'NDY':
treatment = 'NDY'
elif treatment_string == None:
treatment = None
else:
treatment = Treatment.query.filter_by(
treatment_name=data["matrix_treatment_id"]
).first() if Treatment.query.filter_by(
treatment_name=data["matrix_treatment_id"]).first() else Treatment(
treatment_name=data["matrix_treatment_id"])
db.session.add(treatment)
db.session.commit()
matrix_dict = {
'treatment':
treatment,
'matrix_split':
coerce_boolean(data["matrix_split"]),
'matrix_composition':
MatrixComposition.query.filter_by(
comp_name=data["matrix_composition_id"]).first(),
'matrix_criteria_size':
data["matrix_criteria_size"],
'matrix_criteria_ontogeny':
coerce_boolean(data["matrix_criteria_ontogeny"]),
'matrix_criteria_age':
coerce_boolean(data["matrix_criteria_age"]),
'matrix_start_month':
data["matrix_start_month"],
'matrix_end_month':
data["matrix_end_month"],
'matrix_start_year':
data["matrix_start_year"],
'matrix_end_year':
data["matrix_end_year"],
'studied_sex':
StudiedSex.query.filter_by(
sex_code=data["matrix_studied_sex_id"]).first(),
'start_season':
StartSeason.query.filter_by(
season_id=data["matrix_start_season_id"]).first()
if data["matrix_start_season_id"] else None,
'end_season':
EndSeason.query.filter_by(
season_id=data["matrix_end_season_id"]).first()
if data["matrix_end_season_id"] else None,
'matrix_fec':
coerce_boolean(data["matrix_fec"]),
'matrix_a_string':
data["matrix_a_string"],
'matrix_f_string':
data["matrix_f_string"],
'matrix_u_string':
data["matrix_u_string"],
'matrix_c_string':
data["matrix_c_string"],
'non_independence':
data["matrix_non_independence"],
'matrix_dimension':
data["matrix_dimension"],
'non_independence_author':
data["matrix_non_independence_author"],
'matrix_complete':
coerce_boolean(data["matrix_complete"]),
'class_number':
data["matrix_class_number"],
'observations':
data["matrix_observations"],
'captivities':
Captivity.query.filter_by(
cap_code=data["matrix_captivity_id"]).first(),
'class_author':
data["matrix_class_author"],
'class_organized':
data["matrix_class_organized"],
'matrix_difficulty':
data["matrix_difficulty"],
'seasonal':
coerce_boolean(data["matrix_seasonal"]),
'survival_issue':
calc_surv_issue(data["matrix_u_string"]),
'periodicity':
data["matrix_periodicity"],
'matrix_irreducible':
is_matrix_irreducible(data["matrix_a_string"]),
'matrix_primitive':
is_matrix_primitive(data["matrix_a_string"]),
'matrix_ergodic':
is_matrix_ergodic(data["matrix_a_string"]),
'matrix_lambda':
calc_lambda(data["matrix_a_string"])
}
matrix_cleaned = data_clean(matrix_dict)
# if not all(value == None for key, value in matrix_cleaned["kwargs"].items() if key not in ignore_keys):
matrix = Matrix(**matrix_cleaned["kwargs"])
db.session.add(matrix)
db.session.commit()
matrix.population_id = pop.id
db.session.add(matrix)
db.session.commit()
''' matrix Version '''
#version = version_data(matrix_cleaned)
matrix_version = Version(**version)
matrix_version.version_number = 1
matrix_version.matrix = matrix
db.session.add(matrix_version)
db.session.commit()
matrix_version.original_version_id = matrix_version.id
db.session.add(matrix_version)
db.session.commit()
''' Fixed '''
fixed = Fixed.query.filter_by(matrix=matrix).first()
if fixed == None:
fixed_dict = {
'matrix':
matrix,
'census_timings':
CensusTiming.query.filter_by(
census_name=data["fixed_census_timing_id"]).first(),
'seed_stage_error':
coerce_boolean(data["fixed_seed_stage_error"]),
'smalls':
Small.query.filter_by(small_name=data["fixed_small_id"]).first(),
'vector_str':
data["matrix_vectors_includes_na"]
}
fixed_cleaned = data_clean(fixed_dict)
fixed = Fixed(**fixed_cleaned["kwargs"])
db.session.add(fixed)
db.session.commit()
''' fixed Version '''
#version = version_data(fixed_cleaned)
fixed_version = Version(**version)
fixed_version.version_number = 1
fixed_version.fixed = fixed
db.session.add(fixed_version)
db.session.commit()
fixed_version.original_version_id = fixed_version.id
db.session.add(fixed_version)
db.session.commit()
def get_versions(self, project_name):
versions = Version.get_versions(project_name, self.mongo)
return [version['version_name'] for version in versions]
def submit_new(data):
species = Species.query.filter_by(species_accepted=data["species_accepted"]).first()
if species == None:
species = Species(species_accepted=data["species_accepted"])
species.gbif_taxon_key = data["species_gbif_taxon_key"]
species.species_author = data["species_author"]
species.species_accepted = data["species_accepted"]
species.species_esa_status = ESAStatus.query.filter_by(status_code=data["species_esa_status_id"]).first()
species.species_common = data["species_common"]
species.species_iucn_status = IUCNStatus.query.filter_by(status_code=data["species_iucn_status_id"]).first()
db.session.add(species)
db.session.commit()
''' Species Version '''
species_version = Version()
species_version.version_number = 0
species_version.species = species
db.session.add(species_version)
db.session.commit()
species_version.version_of_id = species_version.id
species_version.checked = True
species_version.checked_count = 1
species_version.statuses = Status.query.filter_by(status_name="Green").first()
species_version.user = User.query.filter_by(username="******").first()
species_version.database = Database.query.filter_by(database_name="COMPADRE 4").first()
db.session.add(species_version)
db.session.commit()
''' Publication '''
if data["publication_DOI_ISBN"] == None:
publication = Publication.query.filter_by(authors=data["publication_authors"]).filter_by(year=data["publication_year"]).filter_by(name=data["publication_journal_name"]).first()
else:
publication = Publication.query.filter_by(DOI_ISBN=data["publication_DOI_ISBN"]).first()
if publication == None:
publication = Publication()
publication.authors = data["publication_authors"]
publication.year = data["publication_year"]
publication.DOI_ISBN = data["publication_DOI_ISBN"]
publication.additional_source_string = data["publication_additional_source_string"]
publication.name = data["publication_journal_name"]
db.session.add(publication)
db.session.commit()
''' Publication Version '''
publication_version = Version()
publication_version.version_number = 0
publication_version.publication = publication
db.session.add(publication_version)
db.session.commit()
publication_version.version_of_id = publication_version.id
publication_version.checked = True
publication_version.checked_count = 1
publication_version.statuses = Status.query.filter_by(status_name="Green").first()
publication_version.user = User.query.filter_by(username="******").first()
publication_version.database = Database.query.filter_by(database_name="COMPADRE 4").first()
db.session.add(publication_version)
db.session.commit()
''' Trait '''
spand_ex_growth_type = SpandExGrowthType.query.filter_by(type_name=data["trait_spand_ex_growth_type_id"]).first()
dicot_monoc = DicotMonoc.query.filter_by(dicot_monoc_name=data["trait_dicot_monoc_id"]).first()
growth_form_raunkiaer = GrowthFormRaunkiaer.query.filter_by(form_name=data["trait_growth_form_raunkiaer_id"]).first()
organism_type = OrganismType.query.filter_by(type_name=data["trait_organism_type_id"]).first()
angio_gymno = AngioGymno.query.filter_by(angio_gymno_name=data["trait_angio_gymno_id"]).first()
trait = Trait.query.filter_by(species_id=species.id).first()
if trait == None:
trait = Trait()
trait.species_id = species.id
trait.organism_type = organism_type
trait.dicot_monoc = dicot_monoc
trait.angio_gymno = angio_gymno
trait.spand_ex_growth_type = spand_ex_growth_type
trait.growth_form_raunkiaer = growth_form_raunkiaer
db.session.add(trait)
db.session.commit()
''' Trait Version '''
trait_version = Version()
trait_version.version_number = 0
trait_version.trait = trait
db.session.add(trait_version)
db.session.commit()
trait_version.version_of_id = trait_version.id
trait_version.checked = True
trait_version.checked_count = 1
trait_version.statuses = Status.query.filter_by(status_name="Green").first()
trait_version.user = User.query.filter_by(username="******").first()
trait_version.database = Database.query.filter_by(database_name="COMPADRE 4").first()
db.session.add(trait_version)
db.session.commit()
''' Study '''
# What if all none? Will they be grouped together?
purpose_endangered = PurposeEndangered.query.filter_by(purpose_name=data["study_purpose_endangered_id"]).first()
purpose_weed = PurposeWeed.query.filter_by(purpose_name="study_purpose_weed_id").first()
study = Study.query.filter_by(publication_id=publication.id, study_start=data["study_start"], study_end=data["study_end"]).first()
if study == None:
study = Study()
study.study_duration = data["study_duration"]
study.study_start = data["study_start"]
study.study_end = data["study_end"]
study.publication_id = publication.id
study.number_populations = data["study_number_populations"]
db.session.add(study)
db.session.commit()
''' Study Version '''
study_version = Version()
study_version.version_number = 0
study_version.study = study
db.session.add(study_version)
db.session.commit()
study_version.version_of_id = study_version.id
study_version.checked = True
study_version.checked_count = 1
study_version.statuses = Status.query.filter_by(status_name="Green").first()
study_version.user = User.query.filter_by(username="******").first()
study_version.database = Database.query.filter_by(database_name="COMPADRE 4").first()
db.session.add(study_version)
db.session.commit()
''' Population '''
invasive_status_study = InvasiveStatusStudy.query.filter_by(status_name=data["population_invasive_status_study_id"]).first()
invasive_status_elsewhere = InvasiveStatusStudy.query.filter_by(status_name=data["population_invasive_status_elsewhere_id"]).first()
ecoregion = Ecoregion.query.filter_by(ecoregion_code=data["population_ecoregion_id"]).first()
continent = Continent.query.filter_by(continent_name=data["population_continent_id"]).first()
pop = Population.query.filter_by(name=data["population_name"], species_id=species.id, publication_id=publication.id).first()
if pop == None:
pop = Population()
pop.species_author = data["species_author"]
pop.name = data["population_name"]
pop.species_id = species.id
pop.publication_id = publication.id
pop.study_id = study.id
pop.longitude = data["population_longitude"]
pop.latitude = data["population_latitude"]
pop.altitude = data["population_altitude"]
pop.pop_size = data["population_pop_size"]
pop.country = data["population_country"]
pop.invasive_status_study = invasive_status_study
pop.invasive_status_elsewhere = invasive_status_elsewhere
pop.ecoregion = ecoregion
pop.continent = continent
db.session.add(pop)
db.session.commit()
''' Population Version '''
population_version = Version()
population_version.version_number = 0
population_version.population = pop
db.session.add(population_version)
db.session.commit()
population_version.version_of_id = population_version.id
population_version.checked = True
population_version.checked_count = 1
population_version.statuses = Status.query.filter_by(status_name="Green").first()
population_version.user = User.query.filter_by(username="******").first()
population_version.database = Database.query.filter_by(database_name="COMPADRE 4").first()
db.session.add(population_version)
db.session.commit()
''' Taxonomy '''
tax = Taxonomy.query.filter_by(species_id=species.id).first()
if tax == None:
tax = Taxonomy()
tax.species_author = species.species_author
tax.species_accepted = species.species_accepted
tax.authority = None
tax.tpl_version = None
tax.infraspecies_accepted = None
tax.species_epithet_accepted = None
tax.genus_accepted = data["taxonomy_genus_accepted"]
tax.genus = data["taxonomy_genus"]
tax.family = data["taxonomy_family"]
tax.tax_order = data["taxonomy_order"]
tax.tax_class = data["taxonomy_class"]
tax.phylum = data["taxonomy_phylum"]
tax.kingdom = data["taxonomy_kingdom"]
tax.species = species
tax.publication = publication
tax.col_check_date = data["taxonomy_col_check_date"]
tax.col_check_ok = data["taxonomy_col_check_ok"]
db.session.add(tax)
db.session.commit()
''' Taxonomy Version '''
taxonomy_version = Version()
taxonomy_version.version_number = 0
taxonomy_version.taxonomy = tax
db.session.add(taxonomy_version)
db.session.commit()
taxonomy_version.version_of_id = taxonomy_version.id
taxonomy_version.checked = True
taxonomy_version.checked_count = 1
taxonomy_version.statuses = Status.query.filter_by(status_name="Green").first()
taxonomy_version.user = User.query.filter_by(username="******").first()
taxonomy_version.database = Database.query.filter_by(database_name="COMPADRE 4").first()
db.session.add(taxonomy_version)
db.session.commit()
''' Matrix '''
matrix = Matrix()
treatment = Treatment.query.filter_by(treatment_name=data["matrix_treatment_id"]).first()
if treatment == None:
treatment = Treatment(treatment_name=data["matrix_treatment_id"])
matrix.treatment = treatment
matrix.matrix_split = data["matrix_split"]
composition = MatrixComposition.query.filter_by(comp_name=data["matrix_composition_id"]).first()
matrix.matrix_composition = composition
matrix.survival_issue = data["matrix_survival_issue"]
matrix.periodicity = data["matrix_periodicity"]
matrix.matrix_criteria_size = data["matrix_criteria_size"]
matrix.matrix_criteria_ontogeny = coerce_boolean(data["matrix_criteria_ontogeny"])
matrix.matrix_criteria_age = coerce_boolean(data["matrix_criteria_age"])
matrix.matrix_start_month = data["matrix_start_month"]
matrix.matrix_end_month = data["matrix_end_month"]
matrix.matrix_start_year = data["matrix_start_year"]
matrix.matrix_end_year = data["matrix_end_year"]
matrix.studied_sex = StudiedSex.query.filter_by(sex_code=data["matrix_studied_sex_id"]).first()
start_season = StartSeason.query.filter_by(season_id=data["matrix_start_season_id"]).first()
end_season = EndSeason.query.filter_by(season_id=data["matrix_end_season_id"]).first()
if start_season != None:
matrix.start_season = start_season
if end_season != None:
matrix.end_season = end_season
matrix.matrix_fec = coerce_boolean(data["matrix_fec"])
matrix.matrix_a_string = data["matrix_a_string"]
matrix.matrix_f_string = data["matrix_f_string"]
matrix.matrix_u_string = data["matrix_u_string"]
matrix.matrix_c_string = data["matrix_c_string"]
matrix.non_independence = data["matrix_non_independence"]
matrix.dimension = data["matrix_dimension"]
matrix.non_independence_author = data["matrix_non_independence_author"]
matrix.matrix_complete = data["matrix_complete"]
matrix.vectors_includes_na = data["matrix_vectors_includes_na"]
matrix.class_number = data["matrix_class_number"]
matrix.observations = data["matrix_observations"]
captivities = Captivity.query.filter_by(cap_code=data["matrix_captivity_id"]).first()
matrix.captivities = captivities
matrix.class_author = data["matrix_class_author"]
matrix.matrix_difficulty = data["matrix_difficulty"]
matrix.independent = data["matrix_independent"]
matrix.seasonal = data["matrix_seasonal"]
matrix.uid = generate_uid(species, publication, pop, matrix)
matrix.population = pop
matrix.study = study
db.session.add(matrix)
db.session.commit()
''' matrix Version '''
matrix_version = Version()
matrix_version.version_number = 0
matrix_version.matrix = matrix
db.session.add(matrix_version)
db.session.commit()
matrix_version.version_of_id = matrix_version.id
matrix_version.checked = True
matrix_version.checked_count = 1
matrix_version.statuses = Status.query.filter_by(status_name="Green").first()
matrix_version.user = User.query.filter_by(username="******").first()
matrix_version.database = Database.query.filter_by(database_name="COMPADRE 4").first()
db.session.add(matrix_version)
db.session.commit()
''' Fixed '''
fixed = Fixed.query.filter_by(matrix=matrix).first()
if fixed == None:
fixed = Fixed()
fixed.matrix = matrix
fixed.census_timings = CensusTiming.query.filter_by(census_name=data["fixed_census_timing_id"]).first()
fixed.seed_stage_error = data["fixed_seed_stage_error"]
fixed.smalls = Small.query.filter_by(small_name=data["fixed_small_id"]).first()
db.session.add(fixed)
db.session.commit()
''' fixed Version '''
fixed_version = Version()
fixed_version.version_number = 0
fixed_version.fixed = fixed
db.session.add(fixed_version)
db.session.commit()
fixed_version.version_of_id = fixed_version.id
fixed_version.checked = True
fixed_version.checked_count = 1
fixed_version.statuses = Status.query.filter_by(status_name="Green").first()
fixed_version.user = User.query.filter_by(username="******").first()
fixed_version.database = Database.query.filter_by(database_name="COMPADRE 4").first()
db.session.add(fixed_version)
db.session.commit()
def seed_versions():
data = [
Version(url='http://consilium.s3.amazonaws.com/20fa0246107345308eff7951fcf479a5.wav', length=3, trackId=1), # noqa
Version(url='http://consilium.s3.amazonaws.com/20fa0246107345308eff7951fcf479a5.wav', length=3, trackId=1), # noqa
Version(url='http://consilium.s3.amazonaws.com/0f2fdad92898484e8dc88370dc335f69.wav', length=3, trackId=2), # noqa
Version(url='http://consilium.s3.amazonaws.com/b802fb363fcc41598f03ecae1837e53f.wav', length=3, trackId=3), # noqa
Version(url='http://consilium.s3.amazonaws.com/b802fb363fcc41598f03ecae1837e53f.wav', length=3, trackId=3), # noqa
Version(url='http://consilium.s3.amazonaws.com/b802fb363fcc41598f03ecae1837e53f.wav', length=3, trackId=3), # noqa
Version(url='http://consilium.s3.amazonaws.com/6284da3d7e2d4010b48cdaf2434c7a3a.wav', length=3, trackId=4), # noqa
Version(url='http://consilium.s3.amazonaws.com/af72f90daf104a748059021c446887fe.wav', length=3, trackId=5), # noqa
Version(url='http://consilium.s3.amazonaws.com/5296bdba2a6b4d97a0b8deefdce746dd.wav', length=3, trackId=6), # noqa
Version(url='http://consilium.s3.amazonaws.com/5296bdba2a6b4d97a0b8deefdce746dd.wav', length=3, trackId=6), # noqa
Version(url='http://consilium.s3.amazonaws.com/5296bdba2a6b4d97a0b8deefdce746dd.wav', length=3, trackId=6), # noqa
Version(url='http://consilium.s3.amazonaws.com/4d6eb67af88d4a8c8fc3f10061794348.wav', length=3, trackId=7), # noqa
Version(url='http://consilium.s3.amazonaws.com/e84798374e184f96a400218b03a763a2.wav', length=3, trackId=8), # noqa
Version(url='http://consilium.s3.amazonaws.com/d764cd929aa44e2dbd6a8cf707c145ec.wav', length=3, trackId=9), # noqa
Version(url='http://consilium.s3.amazonaws.com/d764cd929aa44e2dbd6a8cf707c145ec.wav', length=3, trackId=9), # noqa
Version(url='http://consilium.s3.amazonaws.com/d764cd929aa44e2dbd6a8cf707c145ec.wav', length=3, trackId=9), # noqa
Version(url='http://consilium.s3.amazonaws.com/9016d567a4504855800bd661bfcde303.mp3', length=3, trackId=10), # noqa
Version(url='http://consilium.s3.amazonaws.com/2a28e5ee56cb497c95334df4add5deee.wav', length=3, trackId=11), # noqa
Version(url='http://consilium.s3.amazonaws.com/2a28e5ee56cb497c95334df4add5deee.wav', length=3, trackId=11), # noqa
Version(url='http://consilium.s3.amazonaws.com/2a28e5ee56cb497c95334df4add5deee.wav', length=3, trackId=11), # noqa
Version(url='http://consilium.s3.amazonaws.com/2a28e5ee56cb497c95334df4add5deee.wav', length=3, trackId=11), # noqa
Version(url='http://consilium.s3.amazonaws.com/239b184f0d514678bf315e17012cbbc1.wav', length=3, trackId=12), # noqa
Version(url='http://consilium.s3.amazonaws.com/4b2aa022a4c5458e83392347a435a7b1.wav', length=3, trackId=13), # noqa
Version(url='http://consilium.s3.amazonaws.com/2dd44c649d0f494e9a3291de339fc692.wav', length=3, trackId=14), # noqa
Version(url='http://consilium.s3.amazonaws.com/fde1c932ba504abfaa003f1b14dd9c6a.wav', length=3, trackId=15), # noqa
]
for versions in data:
db.session.add(versions)
db.session.commit()
def version():
v = Version()
version = jsonify(major=v.major, minor=v.minor, patch=v.patch)
del v
return version
