forked from enviPath/enviPy
685 lines
27 KiB
Python
685 lines
27 KiB
Python
# legacy counts:
|
|
# count property
|
|
# 8618 referringscenario
|
|
# 6572 halflife
|
|
# 5332 acidity
|
|
# 5253 temperature
|
|
# 5235 spikecompound
|
|
# 5096 soiltexture1
|
|
# 4939 waterstoragecapacity
|
|
# 4783 soiltexture2
|
|
# 4750 soilsource
|
|
# 4736 redox
|
|
# 4681 omcontent
|
|
# 4299 cec
|
|
# 4101 spikeconcentration
|
|
# 3967 humidity
|
|
# 3317 soilclassificationsystem
|
|
# 3154 biomass
|
|
# 2750 minormajor
|
|
# 1776 bulkdens
|
|
# 1588 initorganism
|
|
# 1499 reference
|
|
# 1383 enzyme
|
|
# 1144 sourcescenario
|
|
# 583 confidencelevel
|
|
# 477 acidity_ws
|
|
# 477 halflife_ws
|
|
# 477 samplelocation
|
|
# 451 organiccontent
|
|
# 368 organiccarbonwater
|
|
# 331 rateconstant
|
|
# 313 rulelikelihood
|
|
# 304 columnheight
|
|
# 291 redoxpotential
|
|
# 289 oxygencontent
|
|
# 276 biomass_ws
|
|
# 247 initialmasssediment
|
|
# 243 initialvolumewater
|
|
# 101 proposedintermediate
|
|
# 85 bioreactor
|
|
# 85 finalcompoundconcentration
|
|
# 75 purposeofwwtp
|
|
# 75 typeofaeration
|
|
# 74 location
|
|
# 68 inoculumsource
|
|
# 66 samplingdepth
|
|
# 60 originalsludgeamount
|
|
# 53 tts
|
|
# 52 typeofaddition
|
|
# 51 solventforcompoundsolution
|
|
# 50 sourceofliquidmatrix
|
|
# 43 sludgeretentiontime
|
|
# 36 biologicaltreatmenttechnology
|
|
# 22 aerationtype
|
|
# 16 dissolvedorganiccarbon
|
|
# 13 additionofnutrients
|
|
# 11 nitrogencontent
|
|
# 9 oxygendemand
|
|
# 8 phosphoruscontent
|
|
# 6 Dissolvedoxygenconcentration
|
|
# 4 oxygenuptakerate
|
|
# 1 amionauptakerate
|
|
# 1 volatiletts
|
|
|
|
import logging
|
|
|
|
from envipy_additional_information import HalfLife, HalfLifeWS
|
|
from envipy_additional_information.information import Interval
|
|
from envipy_additional_information.parsers import (
|
|
AcidityParser,
|
|
AdditionParser,
|
|
AerationTypeParser,
|
|
AmmoniaUptakeRateParser,
|
|
BiologicalTreatmentTechnologyParser,
|
|
BiomassParser,
|
|
BioReactorParser,
|
|
BulkDensityParser,
|
|
CECParser,
|
|
ColumnHeightParser,
|
|
CompoundSolutionSolventParser,
|
|
ConfidenceParser,
|
|
DissolvedOrganicCarbonParser,
|
|
DissolvedOxygenConcentrationParser,
|
|
FinalCompoundConcentrationParser,
|
|
HumidityParser,
|
|
InitialSedimentMassParser,
|
|
InitialVolumeWaterParser,
|
|
InoculumSourceParser,
|
|
IntervalParser,
|
|
LocationParser,
|
|
NitrogenContentParser,
|
|
NutrientsParser,
|
|
OMContentParser,
|
|
OrganicCarbonWaterParser,
|
|
OrganicContentParser,
|
|
OriginalSludgeAmountParser,
|
|
OxygenContentParser,
|
|
OxygenDemandParser,
|
|
PFASManufacturingCategoryParser,
|
|
PhosphorusContentParser,
|
|
ProposedIntermediateParser,
|
|
RateConstantParser,
|
|
RedoxParser,
|
|
RedoxPotentialParser,
|
|
ReferenceParser,
|
|
RuleLikelihoodParser,
|
|
SampleLocationParser,
|
|
SamplingDepthParser,
|
|
SludgeRetentionTimeParser,
|
|
SoilClassificationParser,
|
|
SoilSourceParser,
|
|
SoilTexture1Parser,
|
|
SoilTexture2Parser,
|
|
SpikeCompoundParser,
|
|
SpikeConcentrationParser,
|
|
TemperatureParser,
|
|
TotalOrganicCarbonParser,
|
|
TotalSuspendedSolidsParser,
|
|
TransformationProductImportanceParser,
|
|
VolatileTotalSuspendedSolidsParser,
|
|
WaterSedimentAcidityParser,
|
|
WaterSedimentBiomassParser,
|
|
WaterStorageCapacityParser,
|
|
WWTPPurposeParser,
|
|
LiquidMatrixSourceParser,
|
|
OxygenUptakeRateParser,
|
|
InitiatingOrganismParser,
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def extract_influent_effluent(request, influentName, effluentName):
|
|
influent = get_parameter_or_empty_string(request, influentName)
|
|
effluent = get_parameter_or_empty_string(request, effluentName)
|
|
|
|
return influent + ";" + effluent
|
|
|
|
|
|
def get_parameter(request, paramname):
|
|
res = request.POST.get(paramname)
|
|
if res is not None and res.strip() != "":
|
|
return res
|
|
return ValueError("Not all parameters are set!")
|
|
|
|
|
|
def get_parameter_or_empty_string(request, paramname):
|
|
return request.POST.get(paramname, "")
|
|
|
|
|
|
def extract_range(request, value1, value2):
|
|
start = get_parameter_or_empty_string(request, value1)
|
|
end = get_parameter_or_empty_string(request, value2)
|
|
|
|
if start == "":
|
|
start = end
|
|
|
|
if end == "":
|
|
end = start
|
|
|
|
return start + ";" + end
|
|
|
|
|
|
def build_additional_information_from_request(request, type_):
|
|
try:
|
|
if type_ == "amionauptakerate":
|
|
data = extract_range(request, "amionauptakerateStart", "amionauptakerateEnd")
|
|
return AmmoniaUptakeRateParser.from_string(data)
|
|
|
|
elif type_ == "biomass":
|
|
start = get_parameter_or_empty_string(request, "biomassStart")
|
|
start = "-1" if start == "" else start
|
|
end = get_parameter_or_empty_string(request, "biomassEnd")
|
|
end = "-1" if end == "" else end
|
|
data = f"{start};{end}"
|
|
return BiomassParser.from_string(data)
|
|
|
|
elif type_ == "bulkdens":
|
|
data = get_parameter(request, "bulkdensity")
|
|
return BulkDensityParser.from_string(data)
|
|
|
|
elif type_ == "cec":
|
|
data = get_parameter(request, "cecdata")
|
|
return CECParser.from_string(data)
|
|
|
|
elif type_ == "humidity":
|
|
# humidity can be just a double or a double - condition pair
|
|
exp_humid = get_parameter(request, "expHumid")
|
|
try:
|
|
hum_conditions = get_parameter(request, "humConditions")
|
|
data = f"{exp_humid} - {hum_conditions}"
|
|
except ValueError:
|
|
data = exp_humid
|
|
return HumidityParser.from_string(data)
|
|
|
|
elif type_ == "omcontent":
|
|
value_om = get_parameter_or_empty_string(request, "omcontentInOM")
|
|
value_oc = get_parameter_or_empty_string(request, "omcontentINOC")
|
|
data = f"{value_om};OM;{value_oc};OC"
|
|
return OMContentParser.from_string(data)
|
|
|
|
elif type_ == "organiccontent":
|
|
oc_content = extract_range(request, "OC_content_low", "OC_content_high")
|
|
om_content = extract_range(request, "OM_content_low", "OM_content_high")
|
|
data = f"{oc_content};{om_content}"
|
|
return OrganicContentParser.from_string(data)
|
|
|
|
elif type_ == "organiccarbonwater":
|
|
toc_water = extract_range(request, "TOC_low", "TOC_high")
|
|
doc_water = extract_range(request, "DOC_low", "DOC_high")
|
|
data = f"{toc_water};{doc_water}"
|
|
return OrganicCarbonWaterParser.from_string(data)
|
|
|
|
elif type_ == "redox":
|
|
data = get_parameter(request, "redoxType")
|
|
return RedoxParser.from_string(data)
|
|
|
|
elif type_ == "redoxpotential":
|
|
value_range_water = extract_range(request, "lowPotentialWater", "highPotentialWater")
|
|
value_range_sediment = extract_range(
|
|
request, "lowPotentialSediment", "highPotentialSediment"
|
|
)
|
|
data = f"{value_range_water};{value_range_sediment}"
|
|
return RedoxPotentialParser.from_string(data)
|
|
|
|
elif type_ == "samplelocation":
|
|
data = get_parameter(request, "samplelocation")
|
|
return SampleLocationParser.from_string(data)
|
|
|
|
elif type_ == "samplingdepth":
|
|
data = extract_range(request, "samplingDepthMin", "samplingDepthMax")
|
|
return SamplingDepthParser.from_string(data)
|
|
|
|
elif type_ == "initialmasssediment":
|
|
initial_mass = get_parameter(request, "initial_mass_sediment")
|
|
wet_or_dry = get_parameter(request, "wet_or_dry")
|
|
data = f"{initial_mass};{wet_or_dry}"
|
|
return InitialSedimentMassParser.from_string(data)
|
|
|
|
elif type_ == "initialvolumewater":
|
|
data = get_parameter(request, "initialvolumewater")
|
|
return InitialVolumeWaterParser.from_string(data)
|
|
|
|
elif type_ == "sedimentporosity":
|
|
data = get_parameter(request, "sedimentporosity")
|
|
raise ValueError("sedimentporosity is not yet implemented")
|
|
|
|
elif type_ == "columnheight":
|
|
height_sediment = get_parameter_or_empty_string(request, "column_height_sediment")
|
|
height_water = get_parameter_or_empty_string(request, "column_height_water")
|
|
data = f"{height_sediment};{height_water}"
|
|
return ColumnHeightParser.from_string(data)
|
|
|
|
elif type_ == "oxygencontent":
|
|
oxygen_content_water = extract_range(
|
|
request, "oxygen_content_water_low", "oxygen_content_water_high"
|
|
)
|
|
oxygen_content_sediment = extract_range(
|
|
request, "oxygen_content_sediment_low", "oxygen_content_sediment_high"
|
|
)
|
|
data = f"{oxygen_content_water};{oxygen_content_sediment}"
|
|
return OxygenContentParser.from_string(data)
|
|
|
|
elif type_ == "biomass_ws":
|
|
biomass_water_cells = extract_range(request, "start_water_cells", "end_water_cells")
|
|
biomass_sediment_cells = extract_range(
|
|
request, "start_sediment_cells", "end_sediment_cells"
|
|
)
|
|
biomass_sediment_mg = extract_range(request, "start_sediment_mg", "end_sediment_mg")
|
|
data = f"{biomass_water_cells};{biomass_sediment_cells};{biomass_sediment_mg}"
|
|
return WaterSedimentBiomassParser.from_string(data)
|
|
|
|
elif type_ == "soilsource":
|
|
data = get_parameter(request, "soilsourcedata")
|
|
return SoilSourceParser.from_string(data)
|
|
|
|
elif type_ == "soiltexture1":
|
|
data = get_parameter(request, "soilTextureType")
|
|
return SoilTexture1Parser.from_string(data)
|
|
|
|
elif type_ == "soiltexture2":
|
|
sand = get_parameter(request, "sand")
|
|
silt = get_parameter(request, "silt")
|
|
clay = get_parameter(request, "clay")
|
|
data = f"{sand};{silt};{clay}"
|
|
return SoilTexture2Parser.from_string(data)
|
|
|
|
elif type_ == "temperature":
|
|
data = extract_range(request, "temperatureMin", "temperatureMax")
|
|
return TemperatureParser.from_string(data)
|
|
|
|
elif type_ == "reference":
|
|
try:
|
|
data = get_parameter(request, "reference")
|
|
except ValueError:
|
|
data = get_parameter(request, "pmid")
|
|
|
|
return ReferenceParser.from_string(data)
|
|
|
|
elif type_ == "sourcescenario":
|
|
# return get_parameter(request, "sourcescenario")
|
|
raise ValueError("sourcescenario is not yet implemented")
|
|
|
|
elif type_ == "acidity":
|
|
measurement_methods = get_parameter_or_empty_string(request, "acidityType")
|
|
# ACIDITY is separated by " - ". so replace ";" by "-"
|
|
value_range = extract_range(request, "lowPh", "highPh").replace(";", " - ")
|
|
data = f"{value_range};{measurement_methods}"
|
|
return AcidityParser.from_string(data)
|
|
|
|
elif type_ == "acidity_ws":
|
|
measurement_methods_ws = get_parameter_or_empty_string(request, "acidityType")
|
|
# ACIDITY is separated by " - ". so replace ";" by "-"
|
|
value_range_acidity_water = extract_range(
|
|
request, "pH_water_low", "pH_water_high"
|
|
).replace(";", " - ")
|
|
value_range_acidity_sediment = extract_range(
|
|
request, "pH_sediment_low", "pH_sediment_high"
|
|
).replace(";", " - ")
|
|
data = f"{value_range_acidity_water};{value_range_acidity_sediment};{measurement_methods_ws}"
|
|
return WaterSedimentAcidityParser.from_string(data)
|
|
|
|
elif type_ == "waterstoragecapacity":
|
|
wst = get_parameter(request, "wst")
|
|
wst_condition = get_parameter(request, "wstConditions")
|
|
mwst = get_parameter_or_empty_string(request, "maximumWaterstoragecapacity")
|
|
data = f"{wst} - {wst_condition} - {mwst}"
|
|
return WaterStorageCapacityParser.from_string(data)
|
|
|
|
elif type_ == "spikecompound":
|
|
if (
|
|
request.get_parameter("spikeCompSmiles") is not None
|
|
and request.get_parameter("spikeCompSmiles") != ""
|
|
):
|
|
data = get_parameter(request, "spikeCompSmiles")
|
|
elif request.get_parameter("smile") is not None:
|
|
data = get_parameter(request, "smile")
|
|
else:
|
|
data = get_parameter(request, "spikeComp")
|
|
|
|
return SpikeCompoundParser.from_string(data)
|
|
|
|
elif type_ == "spikeconcentration":
|
|
concentration = get_parameter(request, "spikeConcentration")
|
|
unit = get_parameter(request, "spikeconcentrationUnit")
|
|
data = f"{concentration};{unit}"
|
|
return SpikeConcentrationParser.from_string(data)
|
|
|
|
elif type_ == "soilclassificationsystem":
|
|
data = get_parameter(request, "soilclassificationsystem")
|
|
return SoilClassificationParser.from_string(data)
|
|
|
|
elif type_ == "rulelikelihood":
|
|
data = get_parameter(request, "ruleLikelihood")
|
|
return RuleLikelihoodParser.from_string(data)
|
|
|
|
elif type_ == "aerationtype":
|
|
data = get_parameter(request, "aerationtype")
|
|
return AerationTypeParser.from_string(data)
|
|
|
|
elif type_ == "bioreactor":
|
|
bioreactor_type = get_parameter_or_empty_string(request, "bioreactortype")
|
|
bioreactor_size = get_parameter_or_empty_string(request, "bioreactorsize")
|
|
data = f"{bioreactor_type};{bioreactor_size}"
|
|
return BioReactorParser.from_string(data)
|
|
|
|
elif type_ == "finalcompoundconcentration":
|
|
data = get_parameter(request, "finalcompoundconcentration")
|
|
return FinalCompoundConcentrationParser.from_string(data)
|
|
|
|
elif type_ == "inoculumsource":
|
|
data = get_parameter(request, "inoculumsource")
|
|
return InoculumSourceParser.from_string(data)
|
|
|
|
elif type_ == "modelpredictionprob":
|
|
data = get_parameter(request, "modelpredictionprob")
|
|
raise ValueError("modelpredictionprob is not yet implemented")
|
|
|
|
elif type_ == "modelbayespredictionprob":
|
|
data = get_parameter(request, "modelbayespredictionprob")
|
|
raise ValueError("modelbayespredictionprob is not yet implemented")
|
|
|
|
elif type_ == "additionofnutrients":
|
|
data = get_parameter(request, "additionofnutrients")
|
|
return NutrientsParser.from_string(data)
|
|
|
|
elif type_ == "originalsludgeamount":
|
|
data = get_parameter(request, "originalsludgeamount")
|
|
return OriginalSludgeAmountParser.from_string(data)
|
|
|
|
elif type_ == "addparametersmeasured":
|
|
data = get_parameter(request, "addparametersmeasured")
|
|
# return AdditionalMeasuredParameterParser.from_string(data)
|
|
raise ValueError("addparametersmeasured is not yet implemented")
|
|
|
|
elif type_ == "sludgeretentiontime":
|
|
# TODO check constraints
|
|
sludge_type = get_parameter(request, "sludgeretentiontimeType")
|
|
time = get_parameter(request, "sludgeretentiontime")
|
|
data = f"{sludge_type};{time}"
|
|
return SludgeRetentionTimeParser.from_string(data)
|
|
|
|
elif type_ == "solventforcompoundsolution":
|
|
solvent1 = get_parameter(request, "solventforcompoundsolution1")
|
|
|
|
try:
|
|
solvent2 = get_parameter(request, "solventforcompoundsolution2")
|
|
proportion = get_parameter(request, "proportion")
|
|
except ValueError:
|
|
return solvent1
|
|
|
|
solvent3 = ""
|
|
try:
|
|
solvent3 = get_parameter(request, "solventforcompoundsolution3")
|
|
except ValueError:
|
|
return f"{solvent1};{solvent2};{proportion}"
|
|
|
|
data = f"{solvent1};{solvent2};{solvent3};{proportion}"
|
|
return CompoundSolutionSolventParser.from_string(data)
|
|
|
|
elif type_ == "tpa":
|
|
tpa_name = get_parameter(request, "tpaName")
|
|
tpa_ident_level = get_parameter(request, "tpaIdentLevel")
|
|
tpa_structure = get_parameter(request, "tpaStructure")
|
|
data = f"{tpa_name};{tpa_ident_level};{tpa_structure}"
|
|
raise ValueError("tpa is not yet implemented")
|
|
|
|
elif type_ == "tts":
|
|
data = extract_range(request, "ttsStart", "ttsEnd")
|
|
return TotalSuspendedSolidsParser.from_string(data)
|
|
|
|
elif type_ == "typeofaddition":
|
|
data = get_parameter(request, "typeofaddition")
|
|
return AdditionParser.from_string(data)
|
|
|
|
elif type_ == "volatiletts":
|
|
data = extract_range(request, "volatilettsStart", "volatilettsEnd")
|
|
return VolatileTotalSuspendedSolidsParser.from_string(data)
|
|
|
|
elif type_ == "enzyme":
|
|
# name = get_parameter(request, "enzymeName")
|
|
# ec_number = get_parameter(request, "enzymeECNumber")
|
|
raise ValueError("enzyme is not yet implemented")
|
|
|
|
elif type_ == "proposedintermediate":
|
|
prop = get_parameter(request, "proposed")
|
|
return ProposedIntermediateParser.from_string(prop)
|
|
|
|
elif type_ == "confidencelevel":
|
|
data = get_parameter(request, "radioconfidence")
|
|
return ConfidenceParser.from_string(data)
|
|
|
|
elif type_ == "minormajor":
|
|
data = get_parameter(request, "radiomin")
|
|
return TransformationProductImportanceParser.from_string(data)
|
|
|
|
elif type_ == "initorganism":
|
|
data = get_parameter(request, "organism")
|
|
return InitiatingOrganismParser.from_string(data)
|
|
|
|
elif type_ == "oxygenuptakerate":
|
|
data = extract_range(request, "oxygenuptakerateStart", "oxygenuptakerateEnd")
|
|
return OxygenUptakeRateParser.from_string(data)
|
|
|
|
elif type_ == "sourceofliquidmatrix":
|
|
data = get_parameter(request, "sourceofliquidmatrix")
|
|
return LiquidMatrixSourceParser.from_string(data)
|
|
|
|
elif type_ == "halflife":
|
|
lower = get_parameter(request, "lower")
|
|
upper = get_parameter(request, "upper")
|
|
i = Interval(start=float(lower), end=float(upper))
|
|
|
|
comment = get_parameter_or_empty_string(request, "comment")
|
|
source = get_parameter_or_empty_string(request, "source")
|
|
first_order = get_parameter_or_empty_string(request, "firstOrder")
|
|
model = get_parameter_or_empty_string(request, "model")
|
|
fit = get_parameter_or_empty_string(request, "fit")
|
|
|
|
if first_order != "":
|
|
if model != "":
|
|
raise ValueError("not both, model and firstOrder can be set!")
|
|
if first_order == "true":
|
|
model = "SFO"
|
|
else:
|
|
logger.info("firstOrder is set to false which is not meaningful")
|
|
|
|
return HalfLife(model=model, fit=fit, comment=comment, dt50=i, source=source)
|
|
|
|
elif type_ == "halflife_ws": # Halflife in water-sediment systems
|
|
hl_ws_total = extract_range(request, "total_low", "total_high")
|
|
|
|
# When no value is given for water and/or sediment DT50,
|
|
# extract_range results in two values separated by ";"
|
|
# and has to be replaced by empty string
|
|
hl_ws_water = extract_range(request, "water_low", "water_high")
|
|
if hl_ws_water == ";":
|
|
hl_ws_water = ""
|
|
else:
|
|
hl_ws_water = hl_ws_water.replace(";", " - ")
|
|
|
|
hl_ws_sediment = extract_range(request, "sediment_low", "sediment_high")
|
|
if hl_ws_sediment == ";":
|
|
hl_ws_sediment = ""
|
|
else:
|
|
hl_ws_sediment = hl_ws_sediment.replace(";", " - ")
|
|
|
|
comment_ws = get_parameter_or_empty_string(request, "comment_ws")
|
|
source_ws = get_parameter_or_empty_string(request, "source_ws")
|
|
model_ws = get_parameter_or_empty_string(request, "model_ws")
|
|
fit_ws = get_parameter_or_empty_string(request, "fit_ws")
|
|
|
|
dt50_total = IntervalParser.from_string(hl_ws_total)
|
|
dt50_sediment = IntervalParser.from_string(hl_ws_sediment)
|
|
dt50_water = IntervalParser.from_string(hl_ws_water)
|
|
|
|
return HalfLifeWS(
|
|
model=model_ws,
|
|
fit=fit_ws,
|
|
comment=comment_ws,
|
|
dt50_total=dt50_total,
|
|
dt50_water=dt50_water,
|
|
dt50_sediment=dt50_sediment,
|
|
source=source_ws,
|
|
)
|
|
|
|
elif type_ == "kineticevaluation":
|
|
# kinetic_dt50_lower = get_parameter(request, "kineticDt50Lower")
|
|
# kinetic_dt50_upper = get_parameter(request, "kineticDt50Upper")
|
|
#
|
|
# interval = Interval(start=float(kinetic_dt50_lower), end=float(kinetic_dt50_upper))
|
|
#
|
|
# dt50_string = f"{interval.start} - {interval.end}"
|
|
# kinetic_normalized_dt50 = get_parameter_or_empty_string(
|
|
# request, "kineticNormalizedDt50"
|
|
# )
|
|
# kinetic_chi2err = get_parameter_or_empty_string(request, "kineticChi2err")
|
|
# kinetic_t_test = get_parameter_or_empty_string(request, "kineticTTest")
|
|
# kinetic_swarc = get_parameter_or_empty_string(request, "kineticSwarc")
|
|
# kinetic_visual_fit = get_parameter_or_empty_string(request, "kineticVisualFit")
|
|
# kinetic_comment = get_parameter_or_empty_string(request, "kinetiCcomment")
|
|
# kinetic_source = get_parameter_or_empty_string(request, "kineticSource")
|
|
# kinetic_model = get_parameter_or_empty_string(request, "kineticModel")
|
|
# kinetic_k1 = get_parameter_or_empty_string(request, "kineticK1")
|
|
# kinetic_k2 = get_parameter_or_empty_string(request, "kineticK2")
|
|
# kinetic_g = get_parameter_or_empty_string(request, "kineticG")
|
|
# kinetic_tb = get_parameter_or_empty_string(request, "kineticTb")
|
|
# kinetic_alpha = get_parameter_or_empty_string(request, "kineticAlpha")
|
|
# kinetic_beta = get_parameter_or_empty_string(request, "kineticBeta")
|
|
|
|
raise ValueError("kinetic evaluation is not yet implemented")
|
|
|
|
elif type_ == "referringscenario":
|
|
data = get_parameter(request, "referringscenario")
|
|
return ValueError("referringscenario is not yet implemented")
|
|
|
|
elif type_ == "keggreference":
|
|
# kegg_compound = get_parameter(request, "keggCompound")
|
|
# kegg_reaction = get_parameter(request, "keggReaction")
|
|
# kegg_r_pair = get_parameter(request, "keggRPair")
|
|
# kegg_r_class = get_parameter(request, "keggRClass")
|
|
# kegg_metabolic_pathway = get_parameter(request, "keggMetabolicPathway")
|
|
|
|
raise ValueError("kegg reference is not yet implemented")
|
|
|
|
elif type_ == "totalorganiccarbon":
|
|
data = extract_range(request, "totalorganiccarbonStart", "totalorganiccarbonEnd")
|
|
return TotalOrganicCarbonParser.from_string(data)
|
|
|
|
elif type_ == "dissolvedorganiccarbon":
|
|
data = extract_range(
|
|
request, "dissolvedorganiccarbonStart", "dissolvedorganiccarbonEnd"
|
|
)
|
|
return DissolvedOrganicCarbonParser.from_string(data)
|
|
|
|
elif type_ == "purposeofwwtp":
|
|
data = get_parameter(request, "purposeofwwtp")
|
|
return WWTPPurposeParser.from_string(data)
|
|
|
|
elif type_ == "biologicaltreatmenttechnology":
|
|
data = get_parameter(request, "biologicaltreatmenttechnology")
|
|
return BiologicalTreatmentTechnologyParser.from_string(data)
|
|
|
|
elif type_ == "typeofaeration":
|
|
data = get_parameter(request, "typeofaeration")
|
|
return AerationTypeParser.from_string(data)
|
|
|
|
elif type_ == "pfasmanufacturingcategory":
|
|
data = get_parameter(request, "pfasmanufacturingcategory")
|
|
return PFASManufacturingCategoryParser.from_string(data)
|
|
|
|
elif type_ == "phosphoruscontent":
|
|
data = extract_influent_effluent(
|
|
request, "phosphoruscontentInfluent", "phosphoruscontentEffluent"
|
|
)
|
|
return PhosphorusContentParser.from_string(data)
|
|
|
|
elif type_ == "oxygendemand":
|
|
ox_dem_type = get_parameter(request, "oxygendemandType")
|
|
ox_inf_eff = extract_influent_effluent(
|
|
request, "oxygendemandInfluent", "oxygendemandEffluent"
|
|
)
|
|
data = f"{ox_dem_type};{ox_inf_eff}"
|
|
return OxygenDemandParser.from_string(data)
|
|
|
|
elif type_ == "nitrogencontent":
|
|
nitrogen_type = get_parameter(request, "nitrogencontentType")
|
|
nit_inf_enf = extract_influent_effluent(
|
|
request, "nitrogencontentInfluent", "nitrogencontentEffluent"
|
|
)
|
|
data = f"{nitrogen_type};{nit_inf_enf}"
|
|
return NitrogenContentParser.from_string(data)
|
|
|
|
elif type_ == "location":
|
|
data = get_parameter(request, "location")
|
|
return LocationParser.from_string(data)
|
|
|
|
elif type_ == "Dissolvedoxygenconcentration":
|
|
data = extract_range(
|
|
request, "DissolvedoxygenconcentrationLow", "DissolvedoxygenconcentrationHigh"
|
|
)
|
|
return DissolvedOxygenConcentrationParser.from_string(data)
|
|
|
|
elif type_ == "lagphase":
|
|
data = get_parameter(request, "lagphase")
|
|
raise ValueError("lagphase is not yet implemented")
|
|
|
|
elif type_ == "rateconstant":
|
|
# Order and value has to be set
|
|
value = extract_range(request, "rateconstantlower", "rateconstantupper")
|
|
if value == ";":
|
|
raise ValueError("Rate constant value has to be set.")
|
|
|
|
order = get_parameter(request, "rateconstantorder")
|
|
|
|
try:
|
|
corrected = get_parameter(request, "rateconstantcorrected")
|
|
except ValueError:
|
|
corrected = ""
|
|
|
|
try:
|
|
rate_cons_comment = get_parameter(request, "rateconstantcomment")
|
|
except ValueError:
|
|
rate_cons_comment = "no comment"
|
|
|
|
# Escape ;
|
|
rate_cons_comment = rate_cons_comment.replace(";", "\\;")
|
|
|
|
data = f"{order};{corrected};{value};{rate_cons_comment}"
|
|
return RateConstantParser.from_string(data)
|
|
|
|
elif type_ == "compoundlabel":
|
|
compound_label = get_parameter(request, "compoundlabel")
|
|
if compound_label is None or compound_label == "":
|
|
raise ValueError("compoundlabel parameter not transmitted or empty")
|
|
|
|
raise ValueError("compoundlabel is not yet implemented")
|
|
|
|
elif type_ == "observation":
|
|
observation_type = get_parameter_or_empty_string(request, "observationType")
|
|
min_occ = get_parameter_or_empty_string(request, "minOcc")
|
|
max_occ = get_parameter_or_empty_string(request, "maxOcc")
|
|
res = f"{observation_type};"
|
|
res += "NA" if min_occ == "" else min_occ
|
|
res += ";"
|
|
res += "NA" if max_occ == "" else max_occ
|
|
|
|
raise ValueError("observation is not yet implemented")
|
|
|
|
elif type_ == "studymoisture":
|
|
# moisture = get_parameter(request, "moisture")
|
|
raise ValueError("moisture is not yet implemented")
|
|
|
|
elif type_ == "studywst":
|
|
# study_wst_cond = get_parameter(request, "studywstcond")
|
|
raise ValueError("studywstcond is not yet implemented")
|
|
|
|
else:
|
|
raise ValueError(f"No corresponding AdditionalInformation for {type_} found!")
|
|
|
|
except Exception as e:
|
|
raise ValueError(
|
|
f"cannot build data string for addinf {type_}: {type(e).__name__} - {str(e)}", e
|
|
)
|