def entry_delete(
self,
lookup,
uuid,
):
"""Entry delete.
:param lookup: The JSON array of the lookup values or the regular expression to delete
:param uuid: The dictionary id
"""
request_data = {
'lookup': lookup,
'uuid': uuid,
}
errors_mapping = {}
errors_mapping['MISSING_FIELDS'] = MissingFields(
'A required field is missing or does not have data in it. The error_subtype holds a array of all the missing fields'
)
errors_mapping['NOT_FOUND'] = NotFound(
'The dictionary or entry can not be found')
errors_mapping['NOT_LIST'] = NotList(
'The field is not a JSON array. The error_subtype holds the name of the field'
)
errors_mapping['NOT_PERMITTED'] = NotPermitted(
'You are not permitted to do this')
query_data = {
'api': self._api,
'url': '/dictionary/entry/delete',
'request_data': request_data,
'errors_mapping': errors_mapping,
'required_sid': True,
}
return QueryO(**query_data)
def entries(
self,
uuid,
lookup=None,
):
"""Entries.
:param uuid: The dictionary id
:param lookup: Only return the entry for the optional lookup entry (optional)
"""
request_data = {
'lookup': lookup,
'uuid': uuid,
}
errors_mapping = {}
errors_mapping['MISSING_FIELDS'] = MissingFields(
'A required field is missing or does not have data in it. The error_subtype holds a array of all the missing fields'
)
errors_mapping['NOT_FOUND'] = NotFound(
'The dictionary can not be found')
errors_mapping['NOT_LIST'] = NotList(
'The field is not a JSON array. The error_subtype holds the name of the field'
)
errors_mapping['NOT_PERMITTED'] = NotPermitted(
'You are not permitted to do this')
query_data = {
'api': self._api,
'url': '/dictionary/entries',
'request_data': request_data,
'errors_mapping': errors_mapping,
'required_sid': True,
}
return QueryO(**query_data)
def add(
self,
account_id,
case_sensitive,
lookup,
name,
replace,
object=None,
):
"""Add.
:param account_id: The account id
:param case_sensitive: Flag if the dictionary lookup is case sensitive or not
:param lookup: A JSON array of field names that will be concatenated and MD5 hashed for the dictionary lookup value
:param name: The dictionary name
:param replace: A JSON array of the field names that will be replaced for a successful lookup
:param object: object
Notes:
object - Object this is applied against (Study OR Order OR User_account OR Case)
"""
request_data = {
'replace': replace,
'name': name,
'object': object,
'lookup': lookup,
'case_sensitive': case_sensitive,
'account_id': account_id,
}
errors_mapping = {}
errors_mapping['INVALID_FIELD'] = InvalidField(
'An invalid field name was passed. The error_subtype holds the name of the invalid field'
)
errors_mapping['INVALID_FLAG'] = InvalidFlag(
'An invalid flag was passed. The error_subtype holds the name of the invalid flag'
)
errors_mapping['INVALID_OBJECT'] = InvalidObject(
'An invalid object was passed')
errors_mapping['MISSING_FIELDS'] = MissingFields(
'A required field is missing or does not have data in it. The error_subtype holds a array of all the missing fields'
)
errors_mapping['NOT_FOUND'] = NotFound('The account can not be found')
errors_mapping['NOT_LIST'] = NotList(
'The field is not a JSON array. The error_subtype holds the name of the field'
)
errors_mapping['NOT_PERMITTED'] = NotPermitted(
'You are not permitted to do this')
query_data = {
'api': self._api,
'url': '/dictionary/add',
'request_data': request_data,
'errors_mapping': errors_mapping,
'required_sid': True,
}
return QueryO(**query_data)
def entry_add(
self,
lookup,
replace,
uuid,
regexp=None,
):
"""Entry add.
:param lookup: The JSON array of the lookup values to add. Alternatively a regular expression if the regexp parameter is passed
:param replace: The JSON array of the replacement field values
:param uuid: The dictionary id
:param regexp: An integer value that indicates that this entry is a regular expression (optional)
"""
request_data = {
'lookup': lookup,
'regexp': regexp,
'replace': replace,
'uuid': uuid,
}
errors_mapping = {}
errors_mapping[('INVALID_INTEGER', None)] = InvalidInteger(
'Invalid integer. The error_subtype holds the invalid integer.')
errors_mapping[('INVALID_LOOKUP', None)] = InvalidLookup(
'The lookup does not have the required number of fields')
errors_mapping[('INVALID_REGEXP', None)] = InvalidRegexp(
'Invalid regular expression. The error_subtype holds the invalid regexp.'
)
errors_mapping[('MISSING_FIELDS', None)] = MissingFields(
'A required field is missing or does not have data in it. The error_subtype holds a array of all the missing fields'
)
errors_mapping[('NOT_FOUND',
None)] = NotFound('The dictionary can not be found')
errors_mapping[('NOT_LIST', None)] = NotList(
'The field is not a JSON array. The error_subtype holds the name of the field'
)
errors_mapping[(
'NOT_PERMITTED',
None)] = NotPermitted('You are not permitted to do this')
query_data = {
'api': self._api,
'url': '/dictionary/entry/add',
'request_data': request_data,
'errors_mapping': errors_mapping,
'required_sid': True,
}
return AsyncQueryO(**query_data)
def transform_set(
self,
conditions,
name,
order_by,
replacements,
uuid,
):
"""Transform set.
:param conditions: A JSON array of the transform conditions
:param name: Name of the transform
:param order_by: A numeric ordering value. Transformations are run in this order from lowest to highest
:param replacements: A JSON array of the transform replacements
:param uuid: The transform id
"""
request_data = {
'conditions': conditions,
'name': name,
'order_by': order_by,
'replacements': replacements,
'uuid': uuid,
}
errors_mapping = {}
errors_mapping[('DUPLICATE_ORDER_BY', None)] = DuplicateOrderBy('The order_by value is used by another transform')
errors_mapping[('INVALID_CONDITION', None)] = InvalidCondition('An invalid condition was passed. The error_subtype holds the details on why it is invalid')
errors_mapping[('INVALID_REPLACEMENT', None)] = InvalidReplacement('An invalid replacement was passed. The error_subtype holds the details on why it is invalid')
errors_mapping[('MISSING_FIELDS', None)] = MissingFields('A required field is missing or does not have data in it. The error_subtype holds a array of all the missing fields')
errors_mapping[('NOT_FOUND', None)] = NotFound('The account can not be found')
errors_mapping[('NOT_LIST', None)] = NotList('The field is not a JSON array. The error_subtype holds the name of the field')
errors_mapping[('NOT_PERMITTED', None)] = NotPermitted('You are not permitted to do this')
query_data = {
'api': self._api,
'url': '/hl7/transform/set',
'request_data': request_data,
'errors_mapping': errors_mapping,
'required_sid': True,
}
return QueryO(**query_data)
def add(
self,
account_id,
days_old,
days_old_how,
name,
adults=None,
archive=None,
global_param=None,
max_deletes=None,
minors=None,
modalities=None,
namespaces=None,
owned_phr=None,
shared_from_phr=None,
skinny=None,
study_status_tags=None,
suspended=None,
thin=None,
):
"""Add.
:param account_id: uuid of the account the rule is for
:param days_old: Studies greater than or equal to these days old will be purged
:param days_old_how: How should the days old value be calculated using the 'U'pdated or 'C'reated date
:param name: Name of the purge rule
:param adults: Apply this rule to adults - flag (optional)
:param archive: Archive the studies rather than deleting them - flag (optional)
:param global_param: Flag to make this a global purge rule (optional)
:param max_deletes: Maximum number of purges per run of the rule (optional)
:param minors: Apply this rule to minors - flag (optional)
:param modalities: A JSON array of modalities to limit the rule to (optional)
:param namespaces: A JSON array of namespace uuid to limit the rule to (optional)
:param owned_phr: Apply this rule to owned PHR namespaces - flag (optional)
:param shared_from_phr: If a study was shared from a PHR namespace delete the copy in the PHR namespace as well - flag (optional)
:param skinny: Make the studies skinny rather than deleting - flag (optional)
:param study_status_tags: A comma separated list of study status tags to purge (optional)
:param suspended: This rule is suspended and not applied - flag (optional)
:param thin: Make the studies thin rather than deleting - flag (optional)
"""
request_data = {
'shared_from_phr': shared_from_phr,
'archive': archive,
'max_deletes': max_deletes,
'study_status_tags': study_status_tags,
'skinny': skinny,
'namespaces': namespaces,
'minors': minors,
'name': name,
'modalities': modalities,
'owned_phr': owned_phr,
'days_old_how': days_old_how,
'global_param': global_param,
'adults': adults,
'account_id': account_id,
'suspended': suspended,
'thin': thin,
'days_old': days_old,
}
errors_mapping = {}
errors_mapping['GT_ZERO'] = GtZero(
'The parameter must be great than zero. The error_subtype holds the name of the parameter'
)
errors_mapping['INVALID_FLAG'] = InvalidFlag(
'An invalid flag was passed. The error_subtype holds the name of the invalid flag'
)
errors_mapping['MISSING_FIELDS'] = MissingFields(
'A required field is missing or does not have data in it. The error_subtype holds a array of all the missing fields'
)
errors_mapping['NOT_A_NUMBER'] = NotANumber(
'The parameter must be a valid number. The error_subtype holds the name of the parameter'
)
errors_mapping['NOT_FOUND'] = NotFound(
'The account or namespace was not found. The error_subtype holds the uuid of the not found item'
)
errors_mapping['NOT_LIST'] = NotList(
'The field is not a JSON array. The error_subtype holds the name of the field'
)
errors_mapping['NOT_PERMITTED'] = NotPermitted(
'You are not permitted to add a purge to that account')
errors_mapping['ONLY_ONE_FLAG'] = OnlyOneFlag(
'You can set either the skinny, thin or archive flag, not multiple'
)
errors_mapping['VALIDATION_FAILED'] = ValidationFailed(
'A field failed validation. The error_subtype holds the name of the invalid field'
)
query_data = {
'api': self._api,
'url': '/purge/add',
'request_data': request_data,
'errors_mapping': errors_mapping,
'required_sid': True,
}
return QueryO(**query_data)
def add(
self,
prompt_for_anonymize,
acceptance_required=None,
account_id=None,
action=None,
anonymize=None,
charge_amount=None,
charge_currency=None,
charge_description=None,
email=None,
filter=None,
include_priors=None,
max_hits=None,
meeting_id=None,
message=None,
minutes_alive=None,
mobile_phone=None,
namespace_id=None,
notify=None,
parameters=None,
password=None,
password_is_dob=None,
password_max_attempts=None,
pin_auth=None,
referer=None,
share_code=None,
share_on_view=None,
skip_email_prompt=None,
study_id=None,
upload_match=None,
use_share_code=None,
):
"""Add.
:param prompt_for_anonymize: Flag to prompt if the anonymization rules should be applied on ingress
:param acceptance_required: Flag that acceptance of TOS is required (optional)
:param account_id: account_id
:param action: action
:param anonymize: Anonymization rules to the applied to any STUDY_UPLOAD done with this link. Rules are formatted as per the rules parameter in /namespace/anonymize (optional)
:param charge_amount: Amount to charge in pennies before the link can be accessed (optional)
:param charge_currency: Charge currency (optional)
:param charge_description: Charge description (optional)
:param email: Email the link to this address (optional)
:param filter: filter
:param include_priors: Include prior studies (optional)
:param max_hits: The maximum number of times the link can be used (optional)
:param meeting_id: UUID of the meeting to associate the link with (optional)
:param message: Message to include in the email (optional)
:param minutes_alive: The maximum number of minutes the link will be alive for (optional)
:param mobile_phone: Send the link to this phone number (optional)
:param namespace_id: namespace_id
:param notify: Comma or space separated list of additional emails to notify of link usage (optional)
:param parameters: JSON array of parameters to add to the redirect URL or return in /namespace/share_code if an upload (optional)
:param password: Link password (optional)
:param password_is_dob: Flag that the password is the patient_birth_date for the study (study_id is required) (optional)
:param password_max_attempts: The maximum number of failed password attempt (optional)
:param pin_auth: An account member email and PIN authentication is required (optional)
:param referer: The link can only be accessed from the specified referer. The referer can be a regexp to match multiple referers (optional)
:param share_code: share code for a STUDY_UPLOAD (optional)
:param share_on_view: Flag to share the study with the email after it is viewed (optional)
:param skip_email_prompt: Skip the prompt for email step (optional)
:param study_id: study_id
:param upload_match: A JSON hash of DICOM tags and regular expressions they must match uploaded against this link (optional)
:param use_share_code: Flag to use the namespace share code settings for a STUDY_UPLOAD (optional)
Notes:
(study_id OR filter AND account_id OR namespace_id) - uuid of the study or a JSON hash of the study filter expression and the account_id or namespace_id if the action is STUDY_UPLOAD
action - Link action (STUDY_LIST OR STUDY_VIEW OR STUDY_UPLOAD)
"""
request_data = {
'share_on_view': share_on_view,
'max_hits': max_hits,
'charge_description': charge_description,
'study_id': study_id,
'action': action,
'anonymize': anonymize,
'pin_auth': pin_auth,
'use_share_code': use_share_code,
'parameters': parameters,
'message': message,
'include_priors': include_priors,
'email': email,
'mobile_phone': mobile_phone,
'referer': referer,
'charge_amount': charge_amount,
'meeting_id': meeting_id,
'password': password,
'password_is_dob': password_is_dob,
'acceptance_required': acceptance_required,
'filter': filter,
'skip_email_prompt': skip_email_prompt,
'share_code': share_code,
'prompt_for_anonymize': prompt_for_anonymize,
'charge_currency': charge_currency,
'minutes_alive': minutes_alive,
'upload_match': upload_match,
'account_id': account_id,
'namespace_id': namespace_id,
'password_max_attempts': password_max_attempts,
'notify': notify,
}
errors_mapping = {}
errors_mapping['INVALID_ACTION'] = InvalidAction(
'An invalid action was passed')
errors_mapping['INVALID_CHARGE'] = InvalidCharge(
'The charge is invalid. The error_subtype holds the details on the error'
)
errors_mapping['INVALID_EMAIL'] = InvalidEmail(
'An invalid email address was passed')
errors_mapping['INVALID_FIELD_NAME'] = InvalidFieldName(
'The field name in the rules hash is invalid. The error_subtype holds the invalid field name'
)
errors_mapping['INVALID_JSON'] = InvalidJson(
'The field is not in valid JSON format. The error_subtype holds the name of the field'
)
errors_mapping['INVALID_PHI_FIELD'] = InvalidPhiField(
'The password_is_phi field is invalid or a study_id was not passed'
)
errors_mapping['INVALID_PHONE'] = InvalidPhone(
'An invalid cellular phone number was passed')
errors_mapping['INVALID_REGEXP'] = InvalidRegexp(
'Invalid regular expression. The error_subtype holds the invalid regexp.'
)
errors_mapping['INVALID_UPLOAD_MATCH'] = InvalidUploadMatch(
'The upload_match is invalid. The error_subtype holds the details on the error'
)
errors_mapping['MISSING_FIELDS'] = MissingFields(
'A required field is missing or does not have data in it. The error_subtype holds a array of all the missing fields'
)
errors_mapping['NOT_FOUND'] = NotFound(
'The patient or study could not be found. The error_subtype holds the uuid that can not be found'
)
errors_mapping['NOT_HASH'] = NotHash('The rules field is not a hash')
errors_mapping['NOT_LIST'] = NotList(
'The field is not a JSON array. The error_subtype holds the name of the field'
)
errors_mapping['NOT_PERMITTED'] = NotPermitted(
'You are not permitted to create links')
errors_mapping['VALIDATE'] = Validate(
'A validation error. The error_subtype holds the details on the error'
)
query_data = {
'api': self._api,
'url': '/link/add',
'request_data': request_data,
'errors_mapping': errors_mapping,
'required_sid': True,
}
return QueryO(**query_data)