def to_query_dto(cls, search_api):
"""Translates the given SearchApiModel into a SearchQueryDto.
:param search_api: (api.search.SearchApiModel)
:return: (dto.search.SearchQueryDto)
"""
asserts.type_of(search_api, SearchApiModel)
query_dto = SearchQueryDto()
map_props(query_dto, search_api, SearchQueryDto._props)
return query_dto
def from_message_ndb(cls, message_ndb):
"""Translates the given Message to MessageDto.
:param message_ndb: (kinds.messages.Message)
:return: (dto.messages.MessageDto)
"""
asserts.type_of(message_ndb, Message)
message_dto = MessageDto()
map_props(message_dto, message_ndb, MessageDto._props)
return message_dto
def from_job_ndb(cls, job_ndb):
"""Translates the given Job to JobDto.
:param job_ndb: (kinds.jobs.Job)
:return: (dto.jobs.JobDto)
"""
asserts.type_of(job_ndb, Job)
job_dto = JobDto()
map_props(job_dto, job_ndb, JobDto._props)
return job_dto
def from_patient_ndb(cls, patient_ndb):
"""Translates the given Patient NDB to PatientDto.
:param patient_ndb: (kinds.accounts.Patient)
:return: (dto.accounts.PatientDto)
"""
asserts.type_of(patient_ndb, Patient)
patient_dto = PatientDto()
map_props(patient_dto, patient_ndb, cls._props)
return patient_dto
def from_caregiver_dto(cls, caregiver_dto):
"""Translates the given CaregiverDto to a CaregiverApiModel.
:param caregiver_dto: (dto.accounts.CaregiverDto)
:return: (api.accounts.CaregiverApiModel)
"""
asserts.type_of(caregiver_dto, CaregiverDto)
caregiver_api = CaregiverApiModel()
map_props(caregiver_api, caregiver_dto, CaregiverDto._props)
return caregiver_api.ToMessage()
def to_job_dto(cls, job_api):
"""Translates the given JobApiModel to a JobDto.
:param job_api: (api.jobs.JobApiModel)
:return: (dto.jobs.JobDto)
"""
asserts.type_of(job_api, JobApiModel)
job_dto = JobDto()
map_props(job_dto, job_api, JobDto._props)
return job_dto
def from_conn_dto(cls, pending_dto):
"""Translates the given PendingDto to a PendingConnApiModel.
:param pending_dto: (dto.connections.PendingDto)
:return: (api.connections.PendingConnApiModel)
"""
asserts.type_of(pending_dto, PendingDto)
pendingconn_api = PendingConnApiModel()
map_props(pendingconn_api, pending_dto, PendingDto._props)
return pendingconn_api.ToMessage()
def from_conn_dto(cls, conn_dto):
"""Translates the given ConnDto to a ConnApiModel.
:param conn_dto: (dto.connections.ConnDto)
:return: (api.connections.ConnApiModel)
"""
asserts.type_of(conn_dto, ConnDto)
conn_api = ConnApiModel()
map_props(conn_api, conn_dto, ConnDto._props)
return conn_api.ToMessage()
def from_account_dto(cls, account_dto):
"""Translates the given AccountDto to an AccountApiModel.
:param account_dto: (dto.accounts.AccountDto)
:return: (api.accounts.AccountApiModel)
"""
asserts.type_of(account_dto, AccountDto)
account_api = AccountApiModel()
map_props(account_api, account_dto, AccountDto._props)
return account_api.ToMessage()
def from_user_dto(cls, user_dto):
"""Translates the given UserDto to a UserApiModel.
:param user_dto: (dto.accounts.UserDto)
:return: (api.accounts.UserApiModel)
"""
asserts.type_of(user_dto, UserDto)
user_api = UserApiModel()
map_props(user_api, user_dto, UserDto._props)
return user_api
def from_patient_dto(cls, patient_dto):
"""Translates the given PatientDto to a PatientApiModel.
:param patient_dto: (dto.accounts.PatientDto)
:return: (api.accounts.PatientApiModel)
"""
asserts.type_of(patient_dto, PatientDto)
patient_api = PatientApiModel()
map_props(patient_api, patient_dto, PatientDto._props)
return patient_api.ToMessage()
def to_account_dto(cls, account_api):
"""Translates the given AccountApiModel to an AccountDto.
:param account_api: (api.accounts.AccountApiModel)
:return: (dto.accounts.AccountDto)
"""
asserts.type_of(account_api, AccountApiModel)
account_dto = AccountDto()
map_props(account_dto, account_api, AccountDto._props)
return account_dto
def to_patient_ndb(cls, patient_dto):
"""Translates the given PatientDto to Patient NDB model.
:param patient_dto: (dto.accounts.PatientDto)
:return: (kinds.accounts.Patient)
"""
asserts.type_of(patient_dto, PatientDto)
patient_ndb = Patient()
map_props(patient_ndb, patient_dto, cls._props)
return patient_ndb
def from_account_ndb(cls, account_ndb):
"""Translates the given Account NDB to AccountDto.
:param account_ndb: (kinds.accounts.Account)
:return: (dto.accounts.AccountDto)
"""
asserts.type_of(account_ndb, Account)
account_dto = AccountDto()
map_props(account_dto, account_ndb, cls._props)
return account_dto
def from_job_dto(cls, job_dto):
"""Translates the given JobDto to an JobApiModel.
:param job_dto: (dto.jobs.JobDto)
:return: (api.jobs.JobApiModel)
"""
asserts.type_of(job_dto, JobDto)
job_api = JobApiModel()
map_props(job_api, job_dto, JobDto._props)
return job_api.ToMessage()
def to_caregiver_dto(cls, caregiver_api):
"""Translates the given CaregiverApiModel to a CaregiverDto.
:param caregiver_api: (api.accounts.CaregiverApiModel)
:return: (dto.accounts.CaregiverDto)
"""
asserts.type_of(caregiver_api, CaregiverApiModel)
caregiver_dto = CaregiverDto()
map_props(caregiver_dto, caregiver_api, CaregiverDto._props)
return caregiver_dto
def from_caregiver_ndb(cls, caregiver_ndb):
"""Translates the given Caregiver NDB to CaregiverDto.
:param caregiver_ndb: (kinds.accounts.Caregiver)
:return: (dto.accounts.CaregiverDto)
"""
asserts.type_of(caregiver_ndb, Caregiver)
caregiver_dto = CaregiverDto()
map_props(caregiver_dto, caregiver_ndb, cls._props)
return caregiver_dto
def to_caregiver_ndb(cls, caregiver_dto):
"""Translates the given CaregiverDto to Caregiver NDB model.
:param caregiver_dto: (dto.accounts.CaregiverDto)
:return: (kinds.accounts.Caregiver)
"""
asserts.type_of(caregiver_dto, CaregiverDto)
caregiver_ndb = Caregiver()
map_props(caregiver_ndb, caregiver_dto, cls._props)
return caregiver_ndb
def to_patient_dto(cls, patient_api):
"""Translates the given PatientApiModel to a PatientDto.
:param patient_api: (api.accounts.PatientApiModel)
:return: (dto.accounts.PatientDto)
"""
asserts.type_of(patient_api, PatientApiModel)
patient_dto = PatientDto()
map_props(patient_dto, patient_api, PatientDto._props)
return patient_dto
def from_account_ndb(cls, account_ndb):
"""Builds a UserDto from the given Account NDB model.
:param account_ndb:
:return:
"""
asserts.type_of(account_ndb, Account)
user_dto = UserDto()
map_props(user_dto, account_ndb, cls._props)
user_dto.account_id = account_ndb.id
return user_dto
def to_job_ndb(cls, job_dto):
"""Translates the given JobDto to Job.
:param job_dto: (dto.jobs.JobDto)
:return: (kinds.jobs.Job)
"""
asserts.type_of(job_dto, JobDto)
job_ndb = Job()
map_props(job_ndb, job_dto, Job._props)
return job_ndb
def from_result_dto(cls, result_dto):
"""Translates the given SearchResultDto into a
SearchResultApiModel.
:param result_dto: (dto.search.SearchResultDto)
:return (api.search.SearchResultApiModel)
"""
asserts.type_of(result_dto, SearchResultDto)
result_api = SearchResultApiModel(
user=UserApiModel.from_user_dto(result_dto.user))
map_props(result_api, result_dto, SearchResultDto._props)
return result_api.ToMessage()
def to_account_ndb(cls, account_dto):
"""Translates the given AccountDto to Account NDB model.
:param account_dto: (dto.accounts.AccountDto)
:return: (kinds.accounts.Account)
"""
asserts.type_of(account_dto, AccountDto)
# For now, the attributes map 1:1. It will not always be the case.
# For example, convert enum values to enum indices.
account_ndb = Account()
map_props(account_ndb, account_dto, cls._props)
return account_ndb
