class ClubSchema(ma.ModelSchema):
id = field_for(Club, 'id', dump_only=True)
name = field_for(Club, 'name', dump_only=True)
tag = ma.Nested(TagSchema, many=True)
city = ma.Nested(CitySchema, many=True)
total = fields.Method('get_contacts_len')
def get_contacts_len(self, obj):
# base_city = Contact.query.join(City, Contact.city)
# base_tag = Contact.query.join(Tag, Contact.tag_contact)
# base = base_city.union(base_tag)
if (len(obj.tag) == 0 and len(obj.city) != 0):
total = len([t for x in obj.city for t in x.city_contact])
elif (len(obj.city) == 0 and len(obj.tag) != 0):
total = len([c for x in obj.tag for c in x.contact])
elif (len(obj.city) != 0 and len(obj.tag) != 0):
total_city = [t for x in obj.city for t in x.city_contact]
total_tag = [c for x in obj.tag for c in x.contact]
total = len(set(total_city) & set(total_tag))
else:
total = 0
return {'contact': len(obj.contact), 'tag': total}
class meta:
model = Club
class ProcessFlowSchema(ma.ModelSchema):
id = field_for(ProcessFlow, 'id', dump_only=True)
name = field_for(ProcessFlow, 'name', dump_only=True)
task_items = ma.Nested(TaskItemSchema , many=True)
class meta:
model = ProcessFlow
class BiospecimenDiagnosisSchema(BaseSchema):
biospecimen_id = field_for(BiospecimenDiagnosis,
'biospecimen_id',
required=True,
load_only=True,
example='BS_ABC2C104')
diagnosis_id = field_for(BiospecimenDiagnosis,
'diagnosis_id',
required=True,
load_only=True,
example='GF_ABB2C104')
class Meta(BaseSchema.Meta):
model = BiospecimenDiagnosis
resource_url = 'api.biospecimen_diagnoses'
collection_url = 'api.biospecimen_diagnoses_list'
exclude = BaseSchema.Meta.exclude + ('biospecimen', 'diagnosis')
_links = ma.Hyperlinks({
'self':
ma.URLFor(Meta.resource_url, kf_id='<kf_id>'),
'collection':
ma.URLFor(Meta.collection_url),
'biospecimen':
ma.URLFor('api.biospecimens', kf_id='<biospecimen_id>'),
'diagnosis':
ma.URLFor('api.diagnoses', kf_id='<diagnosis_id>')
})
class ParameterSchema(ExecutionElementBaseSchema):
"""The schema for arguments.
This class handles constructing the argument specially so that either a reference or a value is always non-null,
but never both.
"""
name = field_for(Parameter, 'name', required=True)
value = fields.Raw()
reference = field_for(Parameter, 'reference', required=False)
variant = field_for(Parameter, 'variant', required=False)
class Meta:
model = Parameter
unknown = EXCLUDE
@validates_schema
def validate_argument(self, data):
has_value = 'value' in data
has_reference = 'reference' in data and bool(data['reference'])
if (not has_value and not has_reference) or (has_value
and has_reference):
raise ValidationError(
'Parameters must have either a value or a reference.',
['value'])
@post_load
def make_instance(self, data):
instance = self.instance or self.get_instance(data)
if instance is not None:
for key, value in data.items():
setattr(instance, key, value)
return instance
return self.opts.model(**data)
class BiospecimenGenomicFileSchema(BaseSchema):
biospecimen_id = field_for(BiospecimenGenomicFile,
'biospecimen_id',
required=True,
load_only=True,
example='BS_ABC2C104')
genomic_file_id = field_for(BiospecimenGenomicFile,
'genomic_file_id',
required=True,
load_only=True,
example='GF_ABB2C104')
class Meta(BaseSchema.Meta):
model = BiospecimenGenomicFile
resource_url = 'api.biospecimen_genomic_files'
collection_url = 'api.biospecimen_genomic_files_list'
exclude = BaseSchema.Meta.exclude + ('biospecimen', 'genomic_file')
_links = ma.Hyperlinks({
'self':
ma.URLFor(Meta.resource_url, kf_id='<kf_id>'),
'collection':
ma.URLFor(Meta.collection_url),
'biospecimen':
ma.URLFor('api.biospecimens', kf_id='<biospecimen_id>'),
'genomic_file':
ma.URLFor('api.genomic_files', kf_id='<genomic_file_id>')
})
class SequencingExperimentGenomicFileSchema(BaseSchema):
sequencing_experiment_id = field_for(SequencingExperimentGenomicFile,
'sequencing_experiment_id',
required=True,
load_only=True,
example='SE_ABB2C104')
genomic_file_id = field_for(SequencingExperimentGenomicFile,
'genomic_file_id',
required=True,
load_only=True,
example='GF_ABB2C104')
class Meta(BaseSchema.Meta):
model = SequencingExperimentGenomicFile
resource_url = 'api.sequencing_experiment_genomic_files'
collection_url = 'api.sequencing_experiment_genomic_files_list'
exclude = BaseSchema.Meta.exclude + ('sequencing_experiment',
'genomic_file')
_links = ma.Hyperlinks({
'self':
ma.URLFor(Meta.resource_url, kf_id='<kf_id>'),
'collection':
ma.URLFor(Meta.collection_url),
'sequencing_experiment':
ma.URLFor('api.sequencing_experiments',
kf_id='<sequencing_experiment_id>'),
'genomic_file':
ma.URLFor('api.genomic_files', kf_id='<genomic_file_id>')
})
class FamilyRelationshipSchema(BaseSchema):
participant1_id = field_for(FamilyRelationship,
'participant1_id',
required=True,
load_only=True,
example='PT_B048J5')
participant2_id = field_for(FamilyRelationship,
'participant2_id',
required=True,
load_only=True,
example='PT_B048J6')
class Meta(BaseSchema.Meta):
model = FamilyRelationship
resource_url = 'api.family_relationships'
collection_url = 'api.family_relationships_list'
exclude = BaseSchema.Meta.exclude + ('participant2', 'participant1')
_links = ma.Hyperlinks({
'self':
ma.URLFor(Meta.resource_url, kf_id='<kf_id>'),
'collection':
ma.URLFor(Meta.collection_url),
'participant1':
ma.URLFor('api.participants', kf_id='<participant1_id>'),
'participant2':
ma.URLFor('api.participants', kf_id='<participant2_id>')
})
class DiagnosisSchema(BaseSchema):
participant_id = field_for(Diagnosis,
'participant_id',
required=True,
load_only=True,
example='PT_DZB048J5')
age_at_event_days = field_for(Diagnosis,
'age_at_event_days',
validate=validate_age,
example=232)
diagnosis_category = field_for(
Diagnosis,
'diagnosis_category',
validate=enum_validation_generator(DIAGNOSIS_CATEGORY_ENUM))
class Meta(BaseSchema.Meta):
model = Diagnosis
resource_url = 'api.diagnoses'
collection_url = 'api.diagnoses_list'
_links = ma.Hyperlinks({
'self':
ma.URLFor(Meta.resource_url, kf_id='<kf_id>'),
'collection':
ma.URLFor(Meta.collection_url),
'participant':
ma.URLFor('api.participants', kf_id='<participant_id>'),
'biospecimen_diagnoses':
ma.URLFor('api.biospecimen_diagnoses_list', diagnosis_id='<kf_id>'),
'biospecimens':
ma.URLFor('api.biospecimens_list', diagnosis_id='<kf_id>')
})
class FormSubmissionSchema(ModelSchema):
class Meta:
model = FormSubmission
id = field_for(FormSubmission, 'id', dump_only=True)
created_at = field_for(FormSubmission, 'created_at', dump_only=True)
updated_at = field_for(FormSubmission, 'updated_at', dump_only=True)
class OutcomeSchema(BaseSchema):
participant_id = field_for(Outcome,
'participant_id',
required=True,
load_only=True,
example='PT_DZB048J5')
age_at_event_days = field_for(Outcome,
'age_at_event_days',
validate=validate_age,
example=232)
vital_status = field_for(
Outcome,
'vital_status',
validate=enum_validation_generator(VITAL_STATUS_ENUM))
disease_related = field_for(
Outcome,
'disease_related',
validate=enum_validation_generator(DISEASE_RELATED_ENUM))
class Meta(BaseSchema.Meta):
model = Outcome
resource_url = 'api.outcomes'
collection_url = 'api.outcomes_list'
_links = ma.Hyperlinks({
'self':
ma.URLFor(Meta.resource_url, kf_id='<kf_id>'),
'collection':
ma.URLFor(Meta.collection_url),
'participant':
ma.URLFor('api.participants', kf_id='<participant_id>')
})
class JobSchema(ma.ModelSchema):
id = field_for(Scrape, 'id', dump_only=True)
status = field_for(Job, 'status', dump_only=True)
timestamp = field_for(Job, 'timestamp', dump_only=True)
meta = field_for(Job, 'meta', dump_only=True)
club = ma.Nested(ClubSchema, many=True)
template = ma.Nested(TemplateSchema, many=True)
class JobSchema(BaseSchema):
created_by_user = fields.Nested(UserSchema,
attribute="created_by",
dump_to="created_by",
only=["id", "name"],
dump_only=True)
created_by = field_for(models.Job,
'created_by',
required=True,
load_only=True)
job_status = field_for(models.JobStatus, 'name', required=False)
scheduled_for = fields.DateTime()
service_name = fields.Nested(ServiceSchema,
attribute="service",
dump_to="service_name",
only=["name"],
dump_only=True)
@validates('scheduled_for')
def validate_scheduled_for(self, value):
_validate_datetime_not_in_past(value)
_validate_datetime_not_more_than_96_hours_in_future(value)
class Meta:
model = models.Job
exclude = ('notifications', 'notifications_sent',
'notifications_delivered', 'notifications_failed')
strict = True
class StudyFileSchema(BaseSchema, IndexdFileSchema):
availability = field_for(
StudyFile,
'availability',
validate=enum_validation_generator(AVAILABILITY_ENUM))
class Meta(BaseSchema.Meta):
model = StudyFile
resource_url = 'api.study_files'
collection_url = 'api.study_files_list'
study_id = field_for(StudyFile, 'study_id', required=True, load_only=True)
latest_did = field_for(StudyFile,
'latest_did',
required=False,
dump_only=True)
_links = ma.Hyperlinks({
'self':
ma.URLFor(Meta.resource_url, kf_id='<kf_id>'),
'collection':
ma.URLFor(Meta.collection_url),
'study':
ma.URLFor('api.studies', kf_id='<study_id>')
})
class CavaticaTaskGenomicFileSchema(BaseSchema):
cavatica_task_id = field_for(CavaticaTaskGenomicFile,
'cavatica_task_id',
required=True,
load_only=True,
example='CT_ABB2C104')
genomic_file_id = field_for(CavaticaTaskGenomicFile,
'genomic_file_id',
required=True,
load_only=True,
example='GF_ABB2C104')
class Meta(BaseSchema.Meta):
model = CavaticaTaskGenomicFile
resource_url = 'api.cavatica_task_genomic_files'
collection_url = 'api.cavatica_task_genomic_files_list'
exclude = BaseSchema.Meta.exclude + ('cavatica_task', 'genomic_file')
_links = ma.Hyperlinks({
'self':
ma.URLFor(Meta.resource_url, kf_id='<kf_id>'),
'collection':
ma.URLFor(Meta.collection_url),
'cavatica_task':
ma.URLFor('api.cavatica_tasks', kf_id='<cavatica_task_id>'),
'genomic_file':
ma.URLFor('api.genomic_files', kf_id='<genomic_file_id>')
})
class TermSchema(ma.ModelSchema):
term = field_for(Term,
'term',
required=True,
validate=validate.Length(min=2, max=100))
full_term = field_for(Term,
'full_term',
validate=validate.Length(min=2, max=100))
# Flask-Marshmallow SQLAlchemy integration
class Meta:
model = Term
translations = ma.Nested(
TranslationSchema,
many=True,
exclude=('downvoters', 'upvoters'),
)
@pre_dump()
def make_acronym(self, data):
""" Convert acronyms to uppercase """
if data and data.is_acronym:
data.term = data.term.upper()
return data
class FormSchema(ModelSchema):
class Meta:
model = Form
id = field_for(User, 'id', dump_only=True)
created_at = field_for(Form, 'created_at', dump_only=True)
updated_at = field_for(Form, 'updated_at', dump_only=True)
def test_field_for_can_override_validators(self, models, session):
field = field_for(models.Student, 'full_name', validate=[validate.Length(max=20)])
assert len(field.validators) == 1
assert field.validators[0].max == 20
field = field_for(models.Student, 'full_name', validate=[])
assert field.validators == []
class ContactTagSerializer(ModelSchema):
name = field_for(Tag, 'name')
color = field_for(Tag, 'color')
class Meta:
model = ContactTag
fields = ('name', 'color', 'note')
class UserSchema(schemas.ModelSchema):
email = fields.Email(
required=True,
validate=[validators.Length(min=3, max=255)],
)
password = field_for(
models.User,
'password',
required=True,
load_only=True,
)
created_at = field_for(models.User, 'created_at', dump_only=True)
class Meta:
model = models.User
fields = (
'id',
'email',
'first_name',
'last_name',
'username',
'password',
'created_at',
)
@validates('email')
def validate_email(self, value, **kwargs):
if models.User.query.filter_by(email=value).scalar():
raise ValidationError('User with given email already exists')
class UserSchema(schemas.ModelSchema):
username = fields.String(
required=True,
validate=[validators.Length(min=3, max=255)],
)
password = field_for(
models.User,
'password',
required=True,
load_only=True,
)
created_at = field_for(models.User, 'created_at', dump_only=True)
class Meta:
model = models.User
fields = (
'id',
'username',
'password',
'created_at',
'is_child',
)
@validates('username')
def validate_username(self, value, **kwargs):
if models.User.query.filter_by(username=value).scalar():
raise ValidationError('User with given username already exists')
class UserSchema(ma.ModelSchema):
class Meta:
model = User
username = field_for(
User,
'username',
required=True,
validate=validate.Length(min=3, max=25),
)
password = field_for(
User,
'password',
required=True,
validate=validate.Length(min=8, max=50),
load_only=True,
)
email = field_for(
User,
'email',
required=False,
validate=(
validate.Length(min=6, max=50),
validate.Email(),
),
)
@post_load
def encrypt_password(self, data):
password = data['password']
data['password'] = guard.encrypt_password(password)
return data
class GenomicFileSchema(BaseSchema, IndexdFileSchema):
class Meta(BaseSchema.Meta, IndexdFileSchema.Meta):
model = GenomicFile
resource_url = 'api.genomic_files'
collection_url = 'api.genomic_files_list'
exclude = (BaseSchema.Meta.exclude + (
'biospecimen',
'sequencing_experiment',
) + (
'task_genomic_files',
'biospecimen_genomic_files',
) + ('sequencing_experiment_genomic_files',
'read_group_genomic_files'))
paired_end = field_for(GenomicFile,
'paired_end',
validate=enum_validation_generator(PAIRED_END_ENUM))
data_type = field_for(GenomicFile,
'data_type',
validate=enum_validation_generator(DATA_TYPE_ENUM))
availability = field_for(
GenomicFile,
'availability',
validate=enum_validation_generator(AVAILABILITY_ENUM))
latest_did = field_for(GenomicFile,
'latest_did',
required=False,
dump_only=True)
_links = ma.Hyperlinks(
{
'self':
ma.URLFor(Meta.resource_url, kf_id='<kf_id>'),
'collection':
ma.URLFor(Meta.collection_url),
'task_genomic_files':
ma.URLFor('api.task_genomic_files_list',
genomic_file_id='<kf_id>'),
'biospecimen_genomic_files':
ma.URLFor('api.biospecimen_genomic_files_list',
genomic_file_id='<kf_id>'),
'read_group_genomic_files':
ma.URLFor('api.read_group_genomic_files_list',
genomic_file_id='<kf_id>'),
'sequencing_experiment_genomic_files':
ma.URLFor('api.sequencing_experiment_genomic_files_list',
genomic_file_id='<kf_id>'),
'read_groups':
ma.URLFor('api.read_groups_list', genomic_file_id='<kf_id>'),
'sequencing_experiments':
ma.URLFor('api.sequencing_experiments_list',
genomic_file_id='<kf_id>'),
'biospecimens':
ma.URLFor('api.biospecimens_list', genomic_file_id='<kf_id>')
},
description='Resource links and pagination')
class ProdOtherMaterialsItemSchema(ma.ModelSchema):
id = field_for(ProdOtherMaterialsItem, 'id', dump_only=True)
quantity = field_for(ProdOtherMaterialsItem, 'quantity', dump_only=True)
other_mat = ma.Nested(OtherMaterialsSchema, many=True)
class meta:
model = ProdOtherMaterialsItem
class ProdAccessoriesItemSchema(ma.ModelSchema):
id = field_for(ProdAccessoriesItem, 'id', dump_only=True)
quantity = field_for(ProdAccessoriesItem, 'quantity', dump_only=True)
accessories_mat = ma.Nested(AccessoriesSchema, many=True)
class meta:
model = ProdAccessoriesItem
class EmployeeBasicSchema(ma.SQLAlchemySchema ):
id = field_for(Employee, 'id', dump_only=True)
name = field_for(Employee, 'name', dump_only=True)
company = ma.Nested(CompanySchema, many=True)
basicpay = field_for(Employee, 'basicpay', dump_only=True)
class meta:
model = Employee
class ProdRawItemSchema(ma.ModelSchema):
id = field_for(ProdRawItem, 'id', dump_only=True)
quantity = field_for(ProdRawItem, 'quantity', dump_only=True)
raw_mat = ma.Nested(RawGoodsSchema, many=True)
class meta:
model = ProdRawItem
class TriggerTargetSchema(ma.ModelSchema):
class Meta:
model = TriggerTarget
id = field_for(TriggerTarget, 'id', dump_only=True)
snsSubscription = field_for(TriggerTarget,
'snsSubscription',
dump_only=True)
class RelativeSchema(ModelSchema):
class Meta:
model = Relative
sqla_session = db.session
left_id = field_for(Relative, "left_id", required=True)
#left_import_id = db.Column(db.Integer, db.ForeignKey('citizen.import_id'), primary_key=True)
right_id = field_for(Relative, "right_id", required=True)
class ProdFinishedItemSchema(ma.ModelSchema):
id = field_for(ProdFinishedItem, 'id', dump_only=True)
quantity = field_for(ProdFinishedItem, 'quantity', dump_only=True)
finished_mat = ma.Nested(FinishedGoodsSchema, many=True)
class meta:
model = ProdFinishedItem
class CitySchema(ma.ModelSchema):
id = field_for(City, 'id', dump_only=True)
name = field_for(City, 'name', dump_only=True)
state = field_for(City, 'state', dump_only=True)
country = field_for(City, 'country', dump_only=True)
class meta:
model = City
