def get_affiliations(**kwargs):
ids = None
if kwargs.get('affiliationID'):
ids = [int(i) for i in kwargs.get('affiliationID').split(',')]
person_first = kwargs.get('firstName')
person_last = kwargs.get('lastName')
org_code = kwargs.get('organizationCode')
Affs = READ.getAffiliations(ids=ids,
personfirst=person_first,
personlast=person_last,
orgcode=org_code)
Aff_list = []
for aff in Affs:
aff_dct = get_vals(aff)
orgs_dct = None
if aff.OrganizationObj:
orgs_dct = get_vals(aff.OrganizationObj)
aff_dct.update({
'Person':get_vals(aff.PersonObj),
'Organization': orgs_dct
})
Aff_list.append(
AffiliationSerializer(aff_dct).data
)
return Aff_list
def get_affiliations(**kwargs):
ids = None
if kwargs.get('affiliationID'):
ids = [int(i) for i in kwargs.get('affiliationID').split(',')]
person_first = kwargs.get('firstName')
person_last = kwargs.get('lastName')
org_code = kwargs.get('organizationCode')
Affs = READ.getAffiliations(ids=ids,
personfirst=person_first,
personlast=person_last,
orgcode=org_code)
Aff_list = []
for aff in Affs:
aff_dct = get_vals(aff)
orgs_dct = None
if aff.OrganizationObj:
orgs_dct = get_vals(aff.OrganizationObj)
aff_dct.update({
'Person': get_vals(aff.PersonObj),
'Organization': orgs_dct
})
Aff_list.append(AffiliationSerializer(aff_dct).data)
return Aff_list
def get_actions(**kwargs):
# TODO: Get relationship to affiliations via ActionBy, currently not in API
ids = kwargs.get('actionID')
acttype = kwargs.get('actionType')
sfid = kwargs.get('samplingFeatureID')
if ids:
ids = [int(i) for i in ids.split(',')]
actions = READ.getActions(ids=ids, type=acttype, sfid=sfid)
act_list = []
for a in actions:
a_dct = get_vals(a)
# Get methods
m_dct = get_vals(a.MethodObj)
orgs_dct = None
if a.MethodObj.OrganizationObj:
orgs_dct = get_vals(a.MethodObj.OrganizationObj)
m_dct.update({'Organization': orgs_dct})
a_dct.update({'Method': m_dct})
act_list.append(ActionSerializer(a_dct).data)
return act_list
def get_methods(**kwargs):
ids = kwargs.get('methodID')
codes = kwargs.get('methodCode')
mtype = kwargs.get('methodType')
if ids:
ids = [int(i) for i in ids.split(',')]
if codes:
codes = codes.split(',')
methods = READ.getMethods(ids=ids,
codes=codes,
type=mtype)
m_list = []
for m in methods:
m_dct = get_vals(m)
orgs_dct = None
if m.OrganizationObj:
orgs_dct = get_vals(m.OrganizationObj)
m_dct.update({
'Organization': orgs_dct
})
m_list.append(
MethodSerializer(m_dct).data
)
return m_list
def samplingfeaturedatasets_creator(sfd):
ds = sfd.datasets.keys()
related = sfd.related_features
all_ds = []
# all_related = []
for d in ds:
ds_dct = get_vals(d)
ds_dct.update({
u'Results': [result_creator(r) for r in sfd.datasets[d]]
})
all_ds.append(ds_dct)
# related_dct = get_vals(r)
# all_related.append(related_dct)
sf = READ.getSamplingFeatures([sfd.SamplingFeatureID])[0]
sf_dct = get_vals(sf)
related_vals = None
if related:
related_vals = get_vals(related)
sf_dct.update({
u'Datasets': all_ds,
u'related_features': related_vals
})
return sf_dct
def samplingfeaturedatasets_creator(sfd):
ds = sfd.datasets.keys()
all_ds = []
for d in ds:
ds_dct = get_vals(d)
ds_dct.update(
{u'Results': [result_creator(r) for r in sfd.datasets[d]]})
all_ds.append(ds_dct)
sf = READ.getSamplingFeatures([sfd.SamplingFeatureID])[0]
sf_dct = get_vals(sf)
sf_dct.update({
u'Datasets': all_ds,
})
return sf_dct
def put(self, user_id, cursor):
if not request.json:
abort(400)
parser = reqparse.RequestParser()
try:
parser.add_argument('username', type=str, required=True)
parser.add_argument('first_name', type=str, required=True)
parser.add_argument('last_name', type=str, required=True)
request_params = parser.parse_args()
except:
abort(400)
response = {'status': 'Access denied'}
responseCode = 403
if session['username'] == user_id:
cursor.callproc(
'updateUser',
get_vals(request_params, 'username', 'first_name',
'last_name'))
user = cursor.fetchone()
cursor.connection.commit()
user['uri'] = request.url
response = {'user': user}
responseCode = 200
return make_response(jsonify(response), responseCode)
def get_variables(**kwargs):
ids = kwargs.get('variableID')
codes = kwargs.get('variableCode')
sitecode = kwargs.get('siteCode')
if ids:
ids = [int(i) for i in ids.split(',')]
if codes:
codes = codes.split(',')
res = kwargs.get('results')
if type(res) in [str, unicode]:
if res.upper() == 'TRUE':
res = True
else:
res = False
varibles = READ.getVariables(ids=ids,
codes=codes,
sitecode=sitecode,
results=res)
vars_list = []
for var in varibles:
var_dct = get_vals(var)
vars_list.append(VariableSerializer(var_dct).data)
return vars_list
def get_variables(**kwargs):
ids = kwargs.get('variableID')
codes = kwargs.get('variableCode')
sitecode = kwargs.get('siteCode')
if ids:
ids = [int(i) for i in ids.split(',')]
if codes:
codes = codes.split(',')
res = kwargs.get('results')
if type(res) in [str, unicode]:
if res.upper() == 'TRUE':
res = True
else:
res = False
varibles = READ.getVariables(ids=ids,
codes=codes,
sitecode=sitecode,
results=res)
vars_list = []
for var in varibles:
var_dct = get_vals(var)
vars_list.append(
VariableSerializer(var_dct).data
)
return vars_list
def get_methods(**kwargs):
ids = kwargs.get('methodID')
codes = kwargs.get('methodCode')
mtype = kwargs.get('methodType')
if ids:
ids = [int(i) for i in ids.split(',')]
if codes:
codes = codes.split(',')
methods = READ.getMethods(ids=ids, codes=codes, type=mtype)
m_list = []
for m in methods:
m_dct = get_vals(m)
m_dct.update({'Organization': get_vals(m.OrganizationObj)})
m_list.append(MethodSerializer(m_dct).data)
return m_list
def result_creator(res):
res_dct = get_vals(res)
act_obj = res.FeatureActionObj.ActionObj
# Get methods
m_dct = get_vals(act_obj.MethodObj)
# Get Organization
orgs_dct = None
if act_obj.MethodObj.OrganizationObj:
orgs_dct = get_vals(act_obj.MethodObj.OrganizationObj)
m_dct.update({
'Organization': orgs_dct
})
a_dct = get_vals(res.FeatureActionObj.ActionObj)
a_dct.update({
'Method': m_dct
})
# Get Feature Action ----
feat_act_dct = get_vals(res.FeatureActionObj)
feat_act_dct.update({
'SamplingFeature': get_vals(res.FeatureActionObj.SamplingFeatureObj),
'Action': a_dct
})
# ------------------------
# Get taxonomic classifier
taxo_dct = None
if res.TaxonomicClassifierObj:
taxo_dct = get_vals(res.TaxonomicClassifierObj)
res_dct.update({
'FeatureAction': feat_act_dct,
'ProcessingLevel': get_vals(res.ProcessingLevelObj),
'TaxonomicClassifier': taxo_dct,
'Unit': get_vals(res.UnitsObj),
'Variable': get_vals(res.VariableObj)
})
return res_dct
def get_datasetresults(**kwargs):
ids = kwargs.get('datasetID')
codes = kwargs.get('datasetCode')
uuids = kwargs.get('datasetUUID')
if ids:
ids = [int(i) for i in kwargs.get('datasetID').split(',')]
if uuids:
uuids = kwargs.get('datasetUUID').split(',')
if codes:
codes = kwargs.get('datasetCode').split(',')
ds_type = kwargs.get('datasetType')
dataSetResults = READ.getDataSetsResults(ids=ids,
codes=codes,
uuids=uuids,
dstype=ds_type)
dsr_list = []
for dsr in dataSetResults:
dsr_dct = get_vals(dsr)
ds_dct = get_vals(dsr.DataSetObj)
res_dct = result_creator(dsr.ResultObj)
dsr_dct.update({
'Result': res_dct,
'DataSet': ds_dct
})
Serializer = DataSetsResultsSerializer(dsr_dct)
if dsr.ResultObj.FeatureActionObj.SamplingFeatureObj.SamplingFeatureTypeCV == 'Specimen':
Serializer.fields['Result'].fields['FeatureAction'].fields['SamplingFeature'] = SpecimensSerializer()
if dsr.ResultObj.FeatureActionObj.SamplingFeatureObj.SamplingFeatureTypeCV == 'Site':
Serializer.fields['Result'].fields['FeatureAction'].fields['SamplingFeature'] = SitesSerializer()
dsr_list.append(
Serializer.data
)
return dsr_list
def result_creator(res):
res_dct = get_vals(res)
act_obj = res.FeatureActionObj.ActionObj
# Get methods
m_dct = get_vals(act_obj.MethodObj)
# Get Organization
orgs_dct = None
if act_obj.MethodObj.OrganizationObj:
orgs_dct = get_vals(act_obj.MethodObj.OrganizationObj)
m_dct.update({'Organization': orgs_dct})
a_dct = get_vals(res.FeatureActionObj.ActionObj)
a_dct.update({'Method': m_dct})
# Get Feature Action ----
feat_act_dct = get_vals(res.FeatureActionObj)
feat_act_dct.update({
'SamplingFeature':
get_vals(res.FeatureActionObj.SamplingFeatureObj),
'Action':
a_dct
})
# ------------------------
# Get taxonomic classifier
taxo_dct = None
if res.TaxonomicClassifierObj:
taxo_dct = get_vals(res.TaxonomicClassifierObj)
res_dct.update({
'FeatureAction': feat_act_dct,
'ProcessingLevel': get_vals(res.ProcessingLevelObj),
'TaxonomicClassifier': taxo_dct,
'Unit': get_vals(res.UnitsObj),
'Variable': get_vals(res.VariableObj)
})
return res_dct
def get_datasetresults(**kwargs):
db_check()
ids = kwargs.get('datasetID')
codes = kwargs.get('datasetCode')
uuids = kwargs.get('datasetUUID')
if ids:
ids = [int(i) for i in kwargs.get('datasetID').split(',')]
if uuids:
uuids = kwargs.get('datasetUUID').split(',')
if codes:
codes = kwargs.get('datasetCode').split(',')
ds_type = kwargs.get('datasetType')
dataSetResults = READ.getDataSetsResults(ids=ids,
codes=codes,
uuids=uuids,
dstype=ds_type)
dsr_list = []
for dsr in dataSetResults:
dsr_dct = get_vals(dsr)
ds_dct = get_vals(dsr.DataSetObj)
res_dct = result_creator(dsr.ResultObj)
dsr_dct.update({'Result': res_dct, 'DataSet': ds_dct})
Serializer = DataSetsResultsSerializer(dsr_dct)
if dsr.ResultObj.FeatureActionObj.SamplingFeatureObj.SamplingFeatureTypeCV == 'Specimen':
Serializer.fields['Result'].fields['FeatureAction'].fields[
'SamplingFeature'] = SpecimensSerializer()
if dsr.ResultObj.FeatureActionObj.SamplingFeatureObj.SamplingFeatureTypeCV == 'Site':
Serializer.fields['Result'].fields['FeatureAction'].fields[
'SamplingFeature'] = SitesSerializer()
dsr_list.append(Serializer.data)
return dsr_list
def samplingfeaturedatasets_creator(sfd):
ds = sfd.datasets.keys()
related = sfd.related_features
all_ds = []
# all_related = []
for d in ds:
ds_dct = get_vals(d)
ds_dct.update(
{u'Results': [result_creator(r) for r in sfd.datasets[d]]})
all_ds.append(ds_dct)
# related_dct = get_vals(r)
# all_related.append(related_dct)
sf = READ.getSamplingFeatures([sfd.SamplingFeatureID])[0]
sf_dct = get_vals(sf)
related_vals = None
if related:
related_vals = get_vals(related)
sf_dct.update({u'Datasets': all_ds, u'related_features': related_vals})
return sf_dct
def get_actions(**kwargs):
# TODO: Get relationship to affiliations via ActionBy, currently not in API
ids = kwargs.get('actionID')
acttype = kwargs.get('actionType')
sfid = kwargs.get('samplingFeatureID')
if ids:
ids = [int(i) for i in ids.split(',')]
actions = READ.getActions(ids=ids,
type=acttype,
sfid=sfid)
act_list = []
for a in actions:
a_dct = get_vals(a)
# Get methods
m_dct = get_vals(a.MethodObj)
orgs_dct = None
if a.MethodObj.OrganizationObj:
orgs_dct = get_vals(a.MethodObj.OrganizationObj)
m_dct.update({
'Organization': orgs_dct
})
a_dct.update({
'Method': m_dct
})
act_list.append(
ActionSerializer(a_dct).data
)
return act_list
def get_people(**kwargs):
ids = None
if kwargs.get('peopleID'):
ids = [int(i) for i in kwargs.get('peopleID').split(',')]
person_first = kwargs.get('firstName')
person_last = kwargs.get('lastName')
Ppl = READ.getPeople(ids=ids, firstname=person_first, lastname=person_last)
Ppl_list = []
for person in Ppl:
ppl_dct = get_vals(person)
Ppl_list.append(PeopleSerializer(ppl_dct).data)
return Ppl_list
def get_units(**kwargs):
ids = kwargs.get('unitsID')
name = kwargs.get('unitsName')
unitstype = kwargs.get('unitsType')
if ids:
ids = [int(i) for i in ids.split(',')]
units = READ.getUnits(ids=ids, name=name, type=unitstype)
units_list = []
for u in units:
units_dct = get_vals(u)
units_list.append(UnitSerializer(units_dct).data)
return units_list
def get_datasets(**kwargs):
codes = kwargs.get('datasetCode')
uuids = kwargs.get('datasetUUID')
if codes:
codes = codes.split(',')
if uuids:
uuids = uuids.split(',')
datasets = READ.getDataSets(codes=codes, uuids=uuids)
ds_list = []
for ds in datasets:
ds_dct = get_vals(ds)
ds_list.append(DataSetSerializer(ds_dct).data)
return ds_list
def get_processinglevels(**kwargs):
ids = kwargs.get('processingLevelID')
codes = kwargs.get('processingLevelCode')
if ids:
ids = [int(i) for i in ids.split(',')]
if codes:
codes = codes.split(',')
proclevels = READ.getProcessingLevels(ids=ids, codes=codes)
pl_list = []
for pl in proclevels:
pl_dct = get_vals(pl)
pl_list.append(ProcessingLevelSerializer(pl_dct).data)
return pl_list
def get_organizations(**kwargs):
ids = kwargs.get('organizationID')
codes = kwargs.get('organizationCode')
if ids:
ids = [int(i) for i in ids.split(',')]
if codes:
codes = codes.split(',')
organizations = READ.getOrganizations(ids=ids, codes=codes)
orgs_list = []
for org in organizations:
org_dct = get_vals(org)
orgs_list.append(OrganizationSerializer(org_dct).data)
return orgs_list
def get_datasets(**kwargs):
codes = kwargs.get('datasetCode')
uuids = kwargs.get('datasetUUID')
if codes:
codes = codes.split(',')
if uuids:
uuids = uuids.split(',')
datasets = READ.getDataSets(codes=codes, uuids=uuids)
ds_list = []
for ds in datasets:
ds_dct = get_vals(ds)
ds_list.append(
DataSetSerializer(ds_dct).data
)
return ds_list
def post(self, cursor):
if not request.json:
abort(400)
parser = reqparse.RequestParser()
try:
parser.add_argument('first_name', type=str, required=True)
parser.add_argument('last_name', type=str, required=True)
parser.add_argument('username', type=str, required=True)
parser.add_argument('password', type=str, required=True)
request_params = parser.parse_args()
except:
abort(400)
user = get_user(cursor, request_params['username'])
if user:
response = {'status': 'Username already taken'}
responseCode = 409
else:
try:
ldapConnection = get_ldapConnection(request_params['username'],
request_params['password'])
ldapConnection.open()
ldapConnection.start_tls()
ldapConnection.bind()
session['username'] = request_params['username']
cursor.callproc(
'addUser',
get_vals(request_params, 'username', 'first_name',
'last_name'))
cursor.connection.commit()
user = cursor.fetchone()
user['uri'] = uri(request.url, user['user_id'])
response = {'user': user}
responseCode = 200
except LDAPException:
abort(403)
finally:
ldapConnection.unbind()
return make_response(jsonify(response), responseCode)
def get_people(**kwargs):
ids = None
if kwargs.get('peopleID'):
ids = [int(i) for i in kwargs.get('peopleID').split(',')]
person_first = kwargs.get('firstName')
person_last = kwargs.get('lastName')
Ppl = READ.getPeople(ids=ids,
firstname=person_first,
lastname=person_last)
Ppl_list = []
for person in Ppl:
ppl_dct = get_vals(person)
Ppl_list.append(
PeopleSerializer(ppl_dct).data
)
return Ppl_list
def get_units(**kwargs):
ids = kwargs.get('unitsID')
name = kwargs.get('unitsName')
unitstype = kwargs.get('unitsType')
if ids:
ids = [int(i) for i in ids.split(',')]
units = READ.getUnits(ids=ids,
name=name,
type=unitstype)
units_list = []
for u in units:
units_dct = get_vals(u)
units_list.append(
UnitSerializer(units_dct).data
)
return units_list
def get_organizations(**kwargs):
ids = kwargs.get('organizationID')
codes = kwargs.get('organizationCode')
if ids:
ids = [int(i) for i in ids.split(',')]
if codes:
codes = codes.split(',')
organizations = READ.getOrganizations(ids=ids,
codes=codes)
orgs_list = []
for org in organizations:
org_dct = get_vals(org)
orgs_list.append(
OrganizationSerializer(org_dct).data
)
return orgs_list
def get_processinglevels(**kwargs):
ids = kwargs.get('processingLevelID')
codes = kwargs.get('processingLevelCode')
if ids:
ids = [int(i) for i in ids.split(',')]
if codes:
codes = codes.split(',')
proclevels = READ.getProcessingLevels(ids=ids,
codes=codes)
pl_list = []
for pl in proclevels:
pl_dct = get_vals(pl)
pl_list.append(
ProcessingLevelSerializer(pl_dct).data
)
return pl_list
def get_samplingfeatures(**kwargs):
ids = None
codes = None
uuids = None
if kwargs.get('samplingFeatureID'):
ids = [int(i) for i in kwargs.get('samplingFeatureID').split(',')]
if kwargs.get('samplingFeatureUUID'):
uuids = kwargs.get('samplingFeatureUUID').split(',')
if kwargs.get('samplingFeatureCode'):
codes = kwargs.get('samplingFeatureCode').split(',')
sf_type = kwargs.get('samplingFeatureType')
res = kwargs.get('results')
if type(res) in [str, unicode]:
if res.upper() == 'TRUE':
res = True
else:
res = False
sampling_features = READ.getSamplingFeatures(ids=ids,
codes=codes,
uuids=uuids,
type=sf_type,
wkt=None,
results=res)
sf_list = []
for sf in sampling_features:
sf_dct = get_vals(sf)
serialized = SamplingFeatureSerializer(sf_dct).data
if sf.SamplingFeatureTypeCV == 'Site':
serialized = SitesSerializer(sf_dct).data
if sf.SamplingFeatureTypeCV == 'Specimen':
serialized = SpecimensSerializer(sf_dct).data
sf_list.append(
serialized
)
return sf_list
def get_samplingfeatures(**kwargs):
db_check()
ids = None
codes = None
uuids = None
if kwargs.get('samplingFeatureID'):
ids = [int(i) for i in kwargs.get('samplingFeatureID').split(',')]
if kwargs.get('samplingFeatureUUID'):
uuids = kwargs.get('samplingFeatureUUID').split(',')
if kwargs.get('samplingFeatureCode'):
codes = kwargs.get('samplingFeatureCode').split(',')
sf_type = kwargs.get('samplingFeatureType')
res = kwargs.get('results')
if type(res) in [str, unicode]:
if res.upper() == 'TRUE':
res = True
else:
res = False
sampling_features = READ.getSamplingFeatures(ids=ids,
codes=codes,
uuids=uuids,
type=sf_type,
wkt=None,
results=res)
sf_list = []
for sf in sampling_features:
sf_dct = get_vals(sf)
serialized = SamplingFeatureSerializer(sf_dct).data
if sf.SamplingFeatureTypeCV == 'Site':
serialized = SitesSerializer(sf_dct).data
if sf.SamplingFeatureTypeCV == 'Specimen':
serialized = SpecimensSerializer(sf_dct).data
sf_list.append(serialized)
return sf_list
