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