def callback(ch, method, props, body):
    """
    принимаем собщение от комитета,
    отправляем ответ обратно комитету
    """
    print(body.decode())

    if props.correlation_id not in EVADER:
        resp_tax = helper.pack_to_str({'taxpayer_id': str(uuid.uuid4())})

        ch.basic_publish(exchange='',
                         routing_key='from_tax',
                         properties=pika.BasicProperties(
                             correlation_id=props.correlation_id,
                             reply_to=props.reply_to),
                         body=resp_tax)
    else:
        message = helper.pack_to_str({
            'response':
            'request failed, person {} is '
            'tax evader'.format(props.correlation_id)
        })

        ch.basic_publish(exchange='',
                         routing_key=props.reply_to,
                         properties=pika.BasicProperties(
                             correlation_id=props.correlation_id),
                         body=message)

    ch.basic_ack(delivery_tag=method.delivery_tag)
Esempio n. 2
0
def callback(ch, method, props, body):
    """
    callback-функция для приема платежей от людей,
    проверяем, что сумма 500, если все ок, присваиваем номер транзакции
    и отправляем человеку и комитету ответ о том, что человек
    успешно совершил оплату
    """
    print(body.decode())
    bank_dict = helper.unpack_str(body)

    if bank_dict['sum'] == 500:
        message = helper.pack_to_str({
            'transaction_id': str(uuid.uuid4()),
            'response': 'ok'
        })
        ch.basic_publish(exchange='direct_bank',
                         routing_key=routing_key,
                         properties=pika.BasicProperties(
                             correlation_id=props.correlation_id),
                         body=message)
    else:
        message = helper.pack_to_str({'response': 'payment failed'})
        ch.basic_publish(exchange='',
                         routing_key=props.reply_to,
                         properties=pika.BasicProperties(
                             correlation_id=props.correlation_id),
                         body=message)

    ch.basic_ack(delivery_tag=method.delivery_tag)
    def waiting_ok(self, ch, method, props, body):
        """
        callback-функция для приема ответов на запрос,
        проверяем соответствие id и в response помещаем полученный body.
        Если полученный response ok, oтправляем запрос на сдачу экзаменов,
        иначе меняем флаг is_final на True
        """
        if self.person_id == props.correlation_id:
            self.response = body.decode()
            pre_ok_dict = helper.unpack_str(body)

            if pre_ok_dict['response'] == 'ok':
                request_exams = helper.pack_to_str({
                    "Person {}".format(props.correlation_id): "I want to pass exams",
                    "exam_result": self.exam_result
                })

                ch.basic_publish(exchange='',
                                 routing_key='exams_center',
                                 properties=pika.BasicProperties(
                                     reply_to=self.callback_queue_exams,
                                     correlation_id=props.correlation_id),
                                 body=request_exams)
            else:
                self.is_final = True
    def passed_exams(self, ch, method, props, body):
        """
        callback-функция для приема предварительного одобрения на запрос,
        проверяем соответствие id и в response помещаем полученный ответ от
        центра сдачи экзаменов. Если полученный response ok, oтправляем
        запрос на сдачу экзаменов, создаем файл с ответом от центра
        экзаменов и отправляем пошлину в банк. Если полученный response
         другой - меняем флаг is_final на True
        """
        if self.person_id == props.correlation_id:
            self.response_from_exams = body.decode()
            dict_exams_response = helper.unpack_str(body)
            if dict_exams_response['response'] == 'ok':

                with open("resp_exams_{}.json".format(props.correlation_id),
                          "w") as write_file: write_file.write(body.decode())

                fee_dict = {
                    'Person {}'.format(props.correlation_id): 'I would like to pay',
                    'type': 'fee',
                    'sum': self.fee_sum
                }
                req_bank = helper.pack_to_str(fee_dict)

                self.channel.basic_publish(exchange='',
                                           routing_key='bank',
                                           properties=pika.BasicProperties(
                                               reply_to=self.callback_queue_bank,
                                               correlation_id=props.correlation_id),
                                           body=req_bank)
                self.exist_file_exams_bank(ch, props)
            else:
                self.is_final = True
        ch.basic_ack(delivery_tag=method.delivery_tag)
def callback(ch, method, props, body):
    """
    callback-функция для приема запрсов для сдачи экзаменов от людей,
    проверяем проходит ли человек установленный порог,
    отправляем ответ о том, что человек сдал экзамены,
    если не сдал - кидаем обратный ответ.
    """
    print(body.decode())
    exam_dict = helper.unpack_str(body)
    if exam_dict['exam_result'] >= 80:
        response = helper.append_smth(body.decode(), {
            'exams_center': 'Yep, you passed!',
            'response': 'ok'
        })

        ch.basic_publish(exchange='',
                         routing_key=props.reply_to,
                         properties=pika.BasicProperties(
                             correlation_id=props.correlation_id),
                         body=response)
    else:
        response = helper.pack_to_str({
            'exams_center':
            'No',
            'response':
            'sorry, you did not pass the exam'
        })
        ch.basic_publish(exchange='',
                         routing_key=props.reply_to,
                         properties=pika.BasicProperties(
                             correlation_id=props.correlation_id),
                         body=response)

    ch.basic_ack(delivery_tag=method.delivery_tag)
Esempio n. 6
0
def mid_mvd_request(ch, method, props, body):
    """
    callback-функция для приема ответов от мид и мвд,
    при наличии файлов и от мид и от мвд
    отправляем запрос в министерство соцобеспечения
    """

    if os.path.isfile('./response_from_mid_{}.json'.format(props.correlation_id)) and \
            os.path.isfile('./response_from_mvd_{}.json'.format(props.correlation_id)):
        with open('response_from_mvd_{}.json'.format(props.correlation_id),
                  "r") as read_file:

            data_to_publish = helper.unpack_file(read_file)
            data_to_publish.update({'mid': 'ok', 'mvd': 'ok'})
            body_to_publish = helper.pack_to_str(data_to_publish)

            ch.basic_publish(exchange='',
                             routing_key='committee_social',
                             properties=pika.BasicProperties(
                                 correlation_id=data_to_publish['correlation_id'],
                                 reply_to=data_to_publish['reply_to']),
                             body=body_to_publish)
        os.remove('response_from_mid_{}.json'.format(props.correlation_id))
        os.remove('response_from_mvd_{}.json'.format(props.correlation_id))

    ch.basic_ack(delivery_tag=method.delivery_tag)
Esempio n. 7
0
def person_fee_request(ch, method, props, body):
    """
    callback-функция для приема ответов от человека (экзамены
    по языку сдал, пошлину оплатил), распаковываем данные из
    файла и сравниваем с полученными значениями. Отправляем запрос
    в налоговую.
    """
    if os.path.isfile('./data_from_bank_{}.json'.format(props.correlation_id)):
        with open("data_from_bank_{}.json".format(props.correlation_id), "r") as read_file:
            bank_dict = helper.unpack_file(read_file)
            if bank_dict['transaction_id'] == body.decode()\
                    and bank_dict['person_id'] == props.correlation_id:
                print("Ok, Person {} payd fee".format(props.correlation_id))

                tax_message = helper.pack_to_str({"Committee":
                                                      "Person {} wants to get a "
                                                      "residence permit".format(
                                                          props.correlation_id)})
                ch.basic_publish(exchange='',
                                 routing_key='committee_tax',
                                 properties=pika.BasicProperties(
                                     reply_to=props.reply_to,
                                     correlation_id=props.correlation_id),
                                 body=tax_message)
        os.remove('./data_from_bank_{}.json'.format(props.correlation_id))

    ch.basic_ack(delivery_tag=method.delivery_tag)
def callback(ch, method, props, body):
    """
    принимаем собщение от мвд, проверяем есть ли человек во
    внутренних базах. Если есть, то кидаем отказ человеку,
    если нет, отправляем ответ обратно мвд.
    """
    if props.correlation_id not in BAD_PERSON_INTERNAL:
        print(body.decode())

        ch.basic_publish(exchange='',
                         routing_key='internal_mvd',
                         properties=pika.BasicProperties(
                             correlation_id=props.correlation_id,
                             reply_to=props.reply_to),
                         body=body.decode())
    else:
        message = helper.pack_to_str({
            'response':
            'request failed, person {} is criminal '
            '(internal db)'.format(props.correlation_id)
        })

        ch.basic_publish(exchange='',
                         routing_key=props.reply_to,
                         properties=pika.BasicProperties(
                             correlation_id=props.correlation_id),
                         body=message)

    ch.basic_ack(delivery_tag=method.delivery_tag)
    def call(self, message):
        # global EXAM_POINTS

        """
        отправляем запрос на получение вида на жительства
        :param message: сообщение запроса
        :return: ответ на запрос
        """
        my_message = helper.pack_to_str({'message_from_person':message})

        # предварительный ок
        self.response = None

        # ответ от экзаменационного центра
        self.response_from_exams = None

        # ответ от банка
        self.response_from_bank = None

        # финальный ответ
        self.final_response = None

        # флаг, если мы не дождались финального ответа
        self.is_final = False

        self.channel.basic_publish(exchange='',
                                   routing_key='approval',
                                   properties=pika.BasicProperties(
                                       reply_to=self.callback_queue,
                                       correlation_id=self.person_id),
                                   body=my_message)
        """
        слушаем очереди, пока ловим self.response_from_exams, 
        self.response и self.response_from_bank. Когда поймали 
        self.response_from_bank, выводим тело self.response, 
        затем выводим тело self.response_from_exams и тело
        self.response_from_bank.
        
        """

        while not self.final_response and not self.is_final:
            self.connection.process_data_events()
        print(self.response)
        print(self.response_from_exams)
        print(self.response_from_bank)
        return self.final_response
Esempio n. 10
0
def tax_request(ch, method, props, body):
    """
    callback-функция для приема ответов от налоговой,
    отправляем итоговый ответ человеку. response ok показывает нам,
    что весь путь запрос прошел верно
    """
    print(body.decode())
    tax_dict = helper.unpack_str(body.decode())
    response = helper.pack_to_str({"response": "ok",
                                   "Committee":"Congrats! Your taxpayer_id "
                                               "{}".format(tax_dict['taxpayer_id'])})
    ch.basic_publish(exchange='',
                     routing_key=props.reply_to,
                     properties=pika.BasicProperties(
                         correlation_id=props.correlation_id),
                     body=response)

    ch.basic_ack(delivery_tag=method.delivery_tag)
Esempio n. 11
0
def social_request(ch, method, props, body):
    """
    callback-функция для приема ответов от министерства соцобеспечения,
    отправляем предварительный ок человеку. response ok показывает нам,
    что весь путь запрос прошел верно
    """
    print(body.decode())
    response = helper.pack_to_str({'response': 'ok',
                                   'Committee': 'Pre-OK. You need to pass exam '
                                                'and pay fee'})

    ch.basic_publish(exchange='',
                     routing_key=props.reply_to,
                     properties=pika.BasicProperties(
                         correlation_id=props.correlation_id),
                     body=response)

    ch.basic_ack(delivery_tag=method.delivery_tag)
def callback(ch, method, props, body):
    """
    принимаем собщение от комитета, проверяем является ли человек
    нелегальным иммигрантом, если является - кидаем ответ человеку
    сразу, что запрос не прошел. Если не является - отправляем
    ответ обратно комитету.
    """
    print(body.decode())

    if props.correlation_id not in ILLEGAL_IMMIGRANT:

        mid_dict = {
            'mid': 'ok',
            'correlation_id': props.correlation_id,
            'reply_to': props.reply_to,
        }
        print(mid_dict)

        # записываем файл с данными от мид
        helper.update_file(
            "response_from_mid_{}.json".format(props.correlation_id),
            body.decode(), mid_dict)

        ch.basic_publish(exchange='direct_mid_mvd',
                         routing_key=routing_key_for_mid_mvd,
                         properties=pika.BasicProperties(
                             correlation_id=props.correlation_id),
                         body="response_from_mid_{}.json".format(
                             props.correlation_id))
    else:
        message = helper.pack_to_str({
            'response':
            'request failed, person {} is '
            'illegal immigrant'.format(props.correlation_id)
        })

        ch.basic_publish(exchange='',
                         routing_key=props.reply_to,
                         properties=pika.BasicProperties(
                             correlation_id=props.correlation_id),
                         body=message)

    ch.basic_ack(delivery_tag=method.delivery_tag)