def get_measures_results_planned(self, system_code, entity_code, stream_id):
from sirius.blueprints.api.local_service.producer import LocalProducer
from sirius.blueprints.api.remote_service.producer import RemoteProducer
from sirius.blueprints.api.local_service.risar.entities import \
RisarEntityCode
implement = Implementation()
reformer = implement.get_reformer(system_code, stream_id)
# /api/integration/<int:api_version>/card/list/
card_list_method = reformer.get_api_method(
SystemCode.LOCAL, RisarEntityCode.CARD, OperationCode.READ_MANY
)
msg = Message(None, stream_id)
msg.to_local_service()
msg.set_request_type()
msg.set_immediate_answer()
msg.set_method(card_list_method['method'], card_list_method['template_url'])
producer = RemoteProducer()
card_msg = producer.send(msg, async=False)
for card_data in card_msg.get_data():
# /api/integration/<int:api_version>/card/<card_id>/measures/list/
measures_list_method = reformer.get_api_method(
SystemCode.LOCAL, RisarEntityCode.MEASURE, OperationCode.READ_MANY
)
dst_url_params = {}
dst_url_params.update({
'card_id': {
'entity': RisarEntityCode.CARD,
'id': str(card_data['card_id']),
}
})
dst_url_entities = dict((val['entity'], val['id']) for val in dst_url_params.values())
dst_param_ids = [dst_url_entities[param_entity] for param_entity in measures_list_method['params_entities']]
dst_url = measures_list_method['template_url'].format(*dst_param_ids)
msg = Message(None, stream_id)
msg.to_local_service()
msg.set_request_type()
msg.set_immediate_answer()
msg.set_method(
measures_list_method['method'],
dst_url,
)
producer = RemoteProducer()
measures_msg = producer.send(msg, async=False)
for measure_data in measures_msg.get_data():
msg = self.create_message(system_code, entity_code) # searchServiceRend
meta = msg.get_header().meta
meta['local_parents_params'] = {
'card_id': {'entity': RisarEntityCode.CARD, 'id': card_data['card_id']},
'measure_id': {'entity': RisarEntityCode.MEASURE, 'id': measure_data['measure_id']},
}
producer = LocalProducer()
producer.send(msg)
def api_client_local_id():
data = request.get_json()
rld = RequestLocalData(data)
implement = Implementation()
reformer = implement.get_reformer(rld.data.get('remote_system_code'),
rld.stream_id)
local_id = reformer.get_local_id_by_remote(
RisarEntityCode.CLIENT,
rld.data.get('remote_entity_code'),
rld.data.get('remote_main_id'),
)
return local_id, rld.stream_id
def api_card_register():
data = request.get_json()
rld = RequestLocalData(data)
implement = Implementation()
reformer = implement.get_reformer(rld.data.get('remote_system_code'),
rld.stream_id)
res = reformer.register_entity_match(
RisarEntityCode.CARD,
rld.data.get('local_main_id'),
rld.data.get('remote_entity_code'),
rld.data.get('remote_main_id'),
)
return res, rld.stream_id
def process(self, msg, rmt_sys_code):
assert isinstance(msg, Message)
res = True
implement = Implementation()
reformer = implement.get_reformer(rmt_sys_code, msg.get_stream_id())
# сценарий обработки сообщения
if msg.is_to_remote:
if msg.is_send_data:
if remote_system.is_passive(rmt_sys_code):
reformed_data = reformer.reform_msg(msg)
reformer.send_to_remote_data(reformed_data)
hdr = msg.get_header()
op_res = OperationResult(msg.get_stream_id())
result_msg = op_res.check(hdr.method, hdr.url)
if result_msg:
self.producer_send_msgs([result_msg])
elif remote_system.is_active(rmt_sys_code):
# todo: не готов вариант взаимодействия с мис
miss_req_msgs = reformer.get_missing_requests(msg)
miss_data_msgs = self.producer_send_msgs(miss_req_msgs)
remote_reformed_data = reformer.get_reformed_data(
msg, miss_data_msgs)
data_store = Difference()
data_store.place(remote_reformed_data)
data_store.commit_all_changes()
else:
raise InternalError(
'Type of remote system is not define: %s' %
rmt_sys_code)
elif msg.is_send_event:
reformed_data = reformer.reform_msg(msg)
res = reformer.send_to_remote_data(reformed_data)
elif msg.is_result:
remote_data = msg.get_source_data()
reformer.conformity_local(remote_data, msg)
elif msg.is_request:
reformed_req = reformer.reform_req(msg)
entity_package = reformer.get_entity_package_by_req(
reformed_req)
self.send_diff_data(entity_package, reformer, reformed_req)
else:
raise InternalError('Unexpected message type')
elif msg.is_to_local:
raise InternalError('Wrong message direct')
else:
raise InternalError('Message direct is not define')
return res
def get_hospital_rec(self, system_code, entity_code, stream_id):
from sirius.blueprints.api.local_service.producer import LocalProducer
from sirius.blueprints.api.remote_service.producer import RemoteProducer
from sirius.blueprints.api.local_service.risar.entities import \
RisarEntityCode
from sirius.blueprints.api.remote_service.tambov.entities import \
TambovEntityCode
implement = Implementation()
reformer = implement.get_reformer(system_code, stream_id)
# /api/integration/<int:api_version>/card/list/
card_list_method = reformer.get_api_method(
SystemCode.LOCAL, RisarEntityCode.CARD, OperationCode.READ_MANY
)
# data = {
# 'filters': {
# 'id': 3 # todo: при тестировании работаем пока с одной картой
# }
# }
msg = Message(None, stream_id)
msg.to_local_service()
msg.set_request_type()
msg.set_immediate_answer()
msg.set_method(card_list_method['method'],
card_list_method['template_url'])
producer = RemoteProducer()
card_msg = producer.send(msg, async=False)
for card_data in card_msg.get_data():
try:
if not reformer.find_remote_id_by_local(
TambovEntityCode.SMART_PATIENT,
RisarEntityCode.CARD,
card_data['card_id'],
):
continue
msg = self.create_message(system_code, entity_code) # searchHspRecord
meta = msg.get_header().meta
meta['local_parents_params'] = {
'card_id': {'entity': RisarEntityCode.CARD, 'id': card_data['card_id']},
}
producer = LocalProducer()
producer.send(msg)
except LoggedException:
pass
def _test_create_miss_prototype_list(self):
from sirius.models.protocol import ProtocolCode
from sirius.blueprints.api.remote_service.tambov.active.referral.srv_prototype_match import \
SrvPrototypeMatch
from sirius.blueprints.api.remote_service.tambov.entities import \
TambovEntityCode
from sirius.blueprints.reformer.api import DataRequest
from sirius.lib.implement import Implementation
from sirius.models.operation import OperationCode
from sirius.models.system import SystemCode
SrvPrototypeMatch.init()
pr_code_map = SrvPrototypeMatch.prototype_code__srv_prototype__map
stream_id = '_test_create_miss_prototype_list'
implement = Implementation()
reformer = implement.get_reformer(SystemCode.TAMBOV, stream_id)
with app.app_context():
srv_api_method = reformer.get_api_method(
reformer.remote_sys_code,
TambovEntityCode.SERVICE,
OperationCode.READ_MANY,
)
org_code = '1434663' # Контрольная МО Тамбова
with open('missing_prototype_code_for_1434663_01.csv', 'w') as pr:
for pr_code in pr_code_map:
prototype_id = SrvPrototypeMatch.get_prototype_id_by_prototype_code(
pr_code)
req = DataRequest(stream_id)
req.set_req_params(
url=srv_api_method['template_url'],
method=srv_api_method['method'],
protocol=ProtocolCode.SOAP,
data={
'clinic': org_code,
'prototype': prototype_id,
},
)
srvs_data = reformer.transfer.execute(req)
if not srvs_data:
pr.write(pr_code + '\n')
def process(self, msg):
assert isinstance(msg, Message)
res = None
hdr = msg.get_header()
# сценарий обработки сообщения
if msg.is_request:
parser, answer = request_by_url(
hdr.method, hdr.url, msg.get_data(), msg.get_stream_id()
)
local_data = parser.get_data(answer)
next_msg = Message(local_data, msg.get_stream_id())
next_msg.to_remote_service()
next_msg.set_send_data_type()
next_msg.get_header().meta.update(hdr.meta)
if msg.is_immediate_answer:
res = next_msg
else:
prod = LocalProducer()
prod.send(next_msg)
elif msg.is_result:
parser, answer = request_by_url(
hdr.method, hdr.url, msg.get_data(), msg.get_stream_id()
)
req_res = parser.get_data(answer)
elif msg.is_send_data:
implement = Implementation()
rmt_sys_code = msg.get_header().meta['remote_system_code']
reformer = implement.get_reformer(rmt_sys_code, msg.get_stream_id())
entities = reformer.reform_msg(msg)
reformer.send_to_local_data(entities, request_by_url)
else:
raise InternalError('Message has not type')
return res
def send(self, msg):
assert isinstance(msg, Message)
res = True
if msg.is_to_local:
# доп. очередь, т.к. основная может быть забита входящим потоком
local_back_task.apply_async(args=(msg, ), queue=back_queue_name)
elif msg.is_to_remote:
if msg.is_send_data:
implement = Implementation()
for rmt_sys_code in remote_system.get_codes():
for queue_name in remote_system.get_queue_names(
rmt_sys_code):
reformer = implement.get_reformer(
rmt_sys_code, msg.get_stream_id())
entity_package = reformer.get_entity_package_by_msg(
msg)
self.send_diff_data(entity_package, reformer, msg,
rmt_sys_code, queue_name)
elif msg.is_send_event:
implement = Implementation()
rmt_sys_code = remote_system.get_event_system_code()
reformer = implement.get_reformer(rmt_sys_code,
msg.get_stream_id())
entity_package = reformer.get_entity_package_by_msg(msg)
msgs = reformer.create_to_remote_messages(entity_package)
res = all(self.send_msgs(msgs, rmt_sys_code, async=False))
elif msg.is_request:
rmt_sys_code = msg.get_header().meta['remote_system_code']
sync_remote_task(msg, rmt_sys_code)
elif msg.is_result:
rmt_sys_code = msg.get_header().meta['remote_system_code']
sync_remote_task(msg, rmt_sys_code)
else:
raise InternalError('Unexpected message type')
else:
raise InternalError('Message direct missing')
return res
def get_tula_schedules_notused(self, system_code, entity_code, stream_id):
from sirius.blueprints.api.local_service.producer import LocalProducer
from sirius.blueprints.api.remote_service.producer import RemoteProducer
from sirius.blueprints.api.local_service.risar.entities import \
RisarEntityCode
implement = Implementation()
reformer = implement.get_reformer(system_code, stream_id)
org_list_method = reformer.get_api_method(
SystemCode.LOCAL, RisarEntityCode.ORGANIZATION, OperationCode.READ_MANY
)
msg = Message(None, stream_id)
msg.to_local_service()
msg.set_request_type()
msg.set_immediate_answer()
msg.set_method(org_list_method['method'],
org_list_method['template_url'])
producer = RemoteProducer()
org_msg = producer.send(msg, async=False)
for org_data in org_msg.get_data():
doctor_list_method = reformer.get_api_method(
SystemCode.LOCAL, RisarEntityCode.DOCTOR, OperationCode.READ_MANY
)
dst_url_params = {}
dst_url_params.update({
'organization': {
'entity': RisarEntityCode.ORGANIZATION,
'id': str(org_data['LPU_id']),
}
})
dst_url_entities = dict(
(val['entity'], val['id']) for val in dst_url_params.values())
dst_param_ids = [dst_url_entities[param_entity] for param_entity in
doctor_list_method['params_entities']]
dst_url = doctor_list_method['template_url'].format(*dst_param_ids)
msg = Message(None, stream_id)
msg.to_local_service()
msg.set_request_type()
msg.set_immediate_answer()
msg.set_method(
doctor_list_method['method'],
dst_url,
)
producer = RemoteProducer()
doctor_msg = producer.send(msg, async=False)
for doctor_data in doctor_msg.get_data():
if not doctor_data['regional_code']:
# мусор
continue
try:
msg = self.create_message(
system_code, entity_code, OperationCode.ADD
) # WebSchedule
meta = msg.get_header().meta
meta['local_parents_params'] = {
'LPU_id': {'entity': RisarEntityCode.ORGANIZATION,
'id': org_data['LPU_id']},
'regional_code': {'entity': RisarEntityCode.DOCTOR,
'id': doctor_data['regional_code']},
}
producer = LocalProducer()
producer.send(msg)
except LoggedException:
pass
def send_exchange_card(self, system_code, entity_code, stream_id):
from sirius.blueprints.api.local_service.producer import LocalProducer
from sirius.blueprints.api.remote_service.producer import RemoteProducer
from sirius.blueprints.api.local_service.risar.entities import \
RisarEntityCode
from sirius.blueprints.api.remote_service.tambov.entities import \
TambovEntityCode
implement = Implementation()
reformer = implement.get_reformer(system_code, stream_id)
# /api/integration/<int:api_version>/card/list/
card_list_method = reformer.get_api_method(
SystemCode.LOCAL, RisarEntityCode.CARD, OperationCode.READ_MANY
)
# todo: фильтр для двойняшек
data = {
'filters': {
'pregnancyWeek': 32, # в рисар нет таких пока
# 'id': 22,
}
}
# data = {
# 'filters': {
# 'id': 14 # todo: при тестировании работаем пока с одной картой
# }
# }
msg = Message(data, stream_id)
msg.to_local_service()
msg.set_request_type()
msg.set_immediate_answer()
msg.set_method(card_list_method['method'], card_list_method['template_url'])
producer = RemoteProducer()
card_msg = producer.send(msg, async=False)
fname = 'exchange_card_template.xml'
rel_path = 'sirius/blueprints/api/remote_service/tambov/active/service/'
with open(os.path.join(rel_path, fname)) as pr:
template_text = pr.read()
exch_card_req = {
'doc': {
'context_type': 'risar_exchange_card',
'template_text': template_text,
'template_name': 'exchange_card',
'id': 0,
'context': '',
'event_id': 345
}
}
for card_data in card_msg.get_data():
try:
if not reformer.find_remote_id_by_local(
TambovEntityCode.SMART_PATIENT,
RisarEntityCode.CARD,
card_data['card_id'],
):
continue
sub_stream_id = get_stream_id()
exch_card_req['doc']['event_id'] = card_data['card_id']
# POST /print_subsystem/fill_template
exch_card_method = reformer.get_api_method(
SystemCode.LOCAL, RisarEntityCode.EXCHANGE_CARD,
OperationCode.ADD
)
msg = Message(exch_card_req, sub_stream_id)
msg.to_local_service()
msg.set_request_type()
msg.set_immediate_answer()
msg.set_method(exch_card_method['method'], exch_card_method['template_url'])
exch_card_msg = producer.send(msg, async=False)
exch_card_data = {
'card_LPU': card_data['card_LPU'],
'exch_card': exch_card_msg.get_data(),
}
msg = Message(exch_card_data, sub_stream_id)
msg.to_remote_service()
msg.set_send_data_type()
meta = msg.get_header().meta
meta['local_entity_code'] = entity_code
meta['local_operation_code'] = OperationCode.ADD
meta['local_main_param_name'] = 'card_id'
meta['local_main_id'] = card_data['card_id']
meta['remote_system_code'] = system_code
meta['local_parents_params'] = {
'card_id': {'entity': RisarEntityCode.CARD, 'id': card_data['card_id']},
'regionalCode': {'entity': RisarEntityCode.ORGANIZATION, 'id': card_data['card_LPU']},
}
LocalProducer().send(msg)
except LoggedException:
pass