Created
November 23, 2021 01:50
-
-
Save duvictor/0fb42c0c7fa1652957be54f09972d426 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| from rest_framework import viewsets | |
| from ..serializers.fornecedor import * | |
| from ..models.models import * | |
| from ..util import model_util, integracao, tipo_documento_util, geral_util, log_arquivo_util | |
| from rest_framework.filters import SearchFilter | |
| from rest_framework.pagination import PageNumberPagination | |
| from rest_framework.response import Response | |
| from rest_framework.request import Request | |
| from rest_framework.parsers import MultiPartParser, FormParser | |
| from zeep import Client | |
| from zeep.transports import Transport | |
| from requests.auth import HTTPBasicAuth | |
| from requests import Session | |
| import os | |
| from django.db.models import Q | |
| from django.http import HttpResponse | |
| from ..negocio import dvf_ng, fornecedor_ng, documento_ng, extrato_fornecedor_ng | |
| from ..util import ambiente_util | |
| import re | |
| from copel.api.negocio import login_ng | |
| import json as json_api | |
| class PaginacaoViews(PageNumberPagination): | |
| def get_paginated_response(self, data): | |
| return Response(data) | |
| class DespachoView(viewsets.ViewSet): | |
| serializer_class = DespachoSerialized | |
| queryset = DespachoEnviadoFornecedor.objects.all().order_by('data_cadastro') | |
| def incluir(self, request): | |
| json = request.data | |
| assunto = json['assunto'] | |
| descricao = json['descricao'] | |
| fornecedor_id = json['fornecedor'] | |
| despacho_ng.incluir(assunto, descricao, fornecedor_id=fornecedor_id) | |
| return api_util.HttpOK('OK') | |
| def listar_despachos(self, request: Request, cnpj) -> Response: | |
| objects = DespachoEnviadoFornecedor.objects.order_by('-num_seq_def').filter(fornecedor__cpf_cnpj=cnpj) | |
| dados = self.serializer_class(objects, many=True).data | |
| return api_util.HttpOK(dados) | |
| class BancoView(viewsets.ModelViewSet): | |
| serializer_class = BancoSerialized | |
| search_fields = ['=codigo'] | |
| filter_backends = [SearchFilter] | |
| queryset = InstituicaoBancaria.objects.all().order_by('nome') | |
| def get_queryset(self): | |
| filtro = self.request.query_params.get('filtro') | |
| if filtro is not None: | |
| condicinonal = Q(nome__contains=filtro) | Q(codigo=filtro) | |
| queryset = InstituicaoBancaria.objects.filter(condicinonal).order_by('nome') | |
| else: | |
| queryset = InstituicaoBancaria.objects.all().order_by('nome') | |
| return queryset | |
| class FornecedorListarView(viewsets.ModelViewSet): | |
| serializer_class = FornecedorListagemSerialized | |
| search_fields = ['nome_fantasia', 'cpf_cnpj', 'nome_responsavel_cadastro', 'codigo_sap'] | |
| filter_backends = [SearchFilter] | |
| queryset = PreCadastroFornecedor.objects.all().order_by('nome_fantasia') | |
| def create(self, request, *args, **kwargs): | |
| raise Exception('Operação inválida para esse path') | |
| def update(self, request, *args, **kwargs): | |
| raise Exception('Operação inválida para esse path') | |
| def destroy(self, request, *args, **kwargs): | |
| raise Exception('Operação inválida para esse path') | |
| def get_queryset(self): | |
| situacao = self.request.query_params.get('situacao') | |
| etapa = self.request.query_params.get('etapa') | |
| codigo_sap = self.request.query_params.get('codigo_sap') | |
| if situacao: | |
| situacao = situacao.replace('/', '') | |
| if etapa: | |
| etapa = etapa.replace('/', '') | |
| if situacao and etapa: | |
| queryset = PreCadastroFornecedor.objects.filter(situacao_cadastro=situacao, etapa_cadastro=etapa).order_by( | |
| 'nome_fantasia') | |
| elif situacao: | |
| queryset = PreCadastroFornecedor.objects.filter(situacao_cadastro=situacao).order_by('nome_fantasia') | |
| elif etapa: | |
| queryset = PreCadastroFornecedor.objects.filter(etapa_cadastro=etapa).order_by('nome_fantasia') | |
| elif codigo_sap: | |
| queryset = PreCadastroFornecedor.objects.filter(codigo_sap=codigo_sap).order_by('nome_fantasia') | |
| else: | |
| queryset = PreCadastroFornecedor.objects.all().order_by('nome_fantasia') | |
| return queryset | |
| class FornecedorView(viewsets.ModelViewSet): | |
| serializer_class = FornecedorSerialized | |
| search_fields = ['nome_fantasia', 'cpf_cnpj', 'nome_responsavel_cadastro', 'codigo_sap'] | |
| filter_backends = [SearchFilter] | |
| queryset = PreCadastroFornecedor.objects.all().order_by('nome_fantasia') | |
| def registrarLogFornecedor(self, texto): | |
| log_arquivo_util.salvar_texto(texto) | |
| def update(self, request, *args, **kwargs): | |
| tab = api_util.obter_parametro(request, 'tab') | |
| self.registrarLogFornecedor("iniciando persistencia fornecedor:\n" + str(request.data)) | |
| response = super().update(request, *args, **kwargs) | |
| self.registrarLogFornecedor("response:\n" + str(response.data)) | |
| id = response.data['num_seq_pcfnr'] | |
| self.registrarLogFornecedor("num_seq_pcfnr: " + str(id)) | |
| forn = PreCadastroFornecedor.objects.get(num_seq_pcfnr=id) | |
| response = self.tratar_sap(forn, tab) | |
| if response.status_code == 200: | |
| # Ativa o vínculo dos documentos | |
| lista_id_tipos_existentes = fornecedor_ps.listar_tipo_documento_ja_vinculado(id) | |
| if len(lista_id_tipos_existentes) == 0: | |
| dvf_ng.ativar_documentos_fornecedor(forn, False, lista_id_tipos_existentes=lista_id_tipos_existentes) | |
| return response | |
| def tratar_sap(self, forn: PreCadastroFornecedor, tab): | |
| pj = PreCadastroFornecedorPj.objects.filter(num_pre_cad_fnr_pfpj=forn.num_seq_pcfnr).first() | |
| valido, campo_faltante = self.validar_dados_obrigatorios_sap(forn, pj) | |
| if not valido: | |
| self.registrarLogFornecedor("num_seq_pcfnr " + str(forn.num_seq_pcfnr) + ": Não enviado ao SAP, falta o campo: " + campo_faltante) | |
| return | |
| # if ambiente_util.is_local_ou_dev(): | |
| if False: #comentado por paulo, 21/11/2021, tinha sido criado como um bypass antes de termos a integracao completa com sap, sap agora retorna o codigo sap | |
| forn.codigo_sap = '9999999' | |
| forn.save() | |
| else: | |
| try: | |
| pf = PreCadastroFornecedorPf.objects.filter(num_pre_cad_fnr_pfpf=forn.num_seq_pcfnr).first() | |
| dados_bancarios = PreCadDadoBancarioFnr.objects.filter(fornecedor_id=forn.num_seq_pcfnr).first() | |
| if not geral_util.ok(forn.codigo_sap) or forn.codigo_sap == '9999999':#verifica se é pra inserir no sap ou atualizar | |
| return self.inserir_sap(forn, pj, pf, dados_bancarios) | |
| else: | |
| if tab == 'cadastro': | |
| return self.atualizar_sap_tab_cadastro(forn, pj, pf) | |
| if tab == 'atividades': | |
| return self.atualizar_sap_tab_atividades(forn, pj, pf) | |
| if tab == 'mei_pf': | |
| return self.atualizar_sap_tab_mei_pf(forn, pj, pf) | |
| if tab == 'dados_bancarios': | |
| return self.atualizar_sap_tab_dados_bancarios(forn, pj, pf, dados_bancarios) | |
| if tab == 'gestores': | |
| # Tab de gestores não tem nenhum dados a ser atualizado no sap | |
| pass | |
| # self.atualizar_sap(forn, pj, pf) | |
| except Exception as e: | |
| self.registrarLogFornecedor("erro_sap: " + str(e)) | |
| def listar_tipo_atividades(self, request: Request) -> Response: | |
| lista = [] | |
| lista.append({'id': 0, 'nome': 'Prestador de serviços'}) | |
| lista.append({'id': 1, 'nome': 'Fornecedor de materiais'}) | |
| return api_util.HttpOK(lista) | |
| def status(self, request: Request, cnpj) -> Response: | |
| objects = PreCadastroFornecedor.objects.filter(cpf_cnpj=cnpj)[0:1] | |
| dados = self.serializer_class(objects, many=True).data | |
| if len(dados) == 0: | |
| return api_util.HttpOK("ERRO: Não existe um fornecedor com o cnpj: " + cnpj) | |
| return api_util.HttpOK(str(dados[0]['etapa_cadastro'])) | |
| def atualizar_situacao(self, request: Request, ids, etapa, situacao) -> Response: | |
| list_id = ids.split(',') | |
| if list_id: | |
| for cod in list_id: | |
| f = PreCadastroFornecedor.objects.filter(pk=cod).first() | |
| if f: | |
| f.etapa_cadastro = etapa | |
| f.situacao_cadastro = situacao | |
| f.save() | |
| else: | |
| return api_util.HttpResponse('Fornecedores não encontrados') | |
| return api_util.HttpOK('Fornecedores atualizados para a etapa: ' + str(etapa) + ' e situação ' + str(situacao)) | |
| def atualizar_sap_tab_cadastro(self, fornp: PreCadastroFornecedor, pj: PreCadastroFornecedorPj, pf: PreCadastroFornecedorPf) -> Response: | |
| # CÓDIGO SAP | |
| codigo_sap = fornp.codigo_sap | |
| is_pj = fornp.indicador_pj_pf.strip() == 'PJ' | |
| # DADOS ENVIADOS NA TAB DE CADASTRO | |
| cpf_cnpj = fornp.cpf_cnpj | |
| nome_fantasia = fornp.nome_fantasia | |
| nome_responsavel_cadastro = fornp.nome_responsavel_cadastro | |
| cpf_responsavel_cadastro = fornp.cpf_responsavel_cadastro | |
| funcao_responsavel_cadastro = fornp.funcao_responsavel_cadastro | |
| email_responsavel_cadastro = fornp.email_responsavel_cadastro | |
| pais = fornp.pais | |
| uf = fornp.uf | |
| cidade = fornp.cidade | |
| endereco_caixa_postal = fornp.endereco_caixa_postal | |
| cep = fornp.cep | |
| endereco_logradouro = fornp.endereco_logradouro | |
| endereco_complemento = fornp.endereco_complemento | |
| endereco_numero = fornp.endereco_numero | |
| endereco_bairro = fornp.endereco_bairro | |
| fuso_horario = fornp.fuso_horario | |
| idioma = fornp.idioma | |
| fone_fixo = fornp.fone_fixo | |
| fone_celular = fornp.fone_celular | |
| email = fornp.email | |
| url_site = fornp.url_site | |
| anexo_simples_nacional = fornp.anexo_simples_nacional | |
| possui_cadastro_cpom = fornp.possui_cadastro_cpom | |
| data_validade_procuracao = fornp.data_validade_procuracao | |
| indicador_pj_pf = fornp.indicador_pj_pf | |
| request_api = { | |
| "IM_BANCO": { | |
| }, | |
| "IM_EMAIL": { | |
| "item": { | |
| "SMTP_ADDR": fornp.email, | |
| "REMARK": "Principal" | |
| } | |
| }, | |
| "IM_INPUT": { | |
| "LIFNR": (fornp.codigo_sap if fornp and fornp.codigo_sap else ""), | |
| "STCD1": (fornp.cpf_cnpj if len(fornp.cpf_cnpj) == 14 and is_pj else ""), | |
| "STCD3": pj.inscricao_estadual if is_pj else "", | |
| "STCD4": (pj.inscricao_municipal if is_pj and pj.inscricao_municipal else ""), | |
| "STCD2": (fornp.cpf_cnpj if len(fornp.cpf_cnpj) == 11 and fornp.indicador_pj_pf.strip() == 'PF' else ''), | |
| "NAME1": fornp.nome_fantasia[:35], | |
| "SORTL": fornp.nome_fantasia[:20], | |
| "NAMEV": geral_util.obter_nome(fornp.nome_responsavel_cadastro)[:35], | |
| "NAMES": geral_util.obter_sobrenome(fornp.nome_responsavel_cadastro)[:35], | |
| "LAND1": (fornp.pais if fornp and fornp.pais else "BR"), | |
| "REGIO": fornp.uf, | |
| "ORT01": re.sub(u'[^a-zA-Z0-9áéíóúÁÉÍÓÚâêîôÂÊÎÔãõÃÕçÇ: ]', '', fornp.cidade[:35]), | |
| "PSTLZ": (fornp.cep if len(fornp.cep) == 9 else fornp.cep[:5] + "-" + fornp.cep[5:9]), | |
| "STRAS": fornp.endereco_logradouro[:35], | |
| "HOUSE_NUM1": (fornp.endereco_numero if fornp and fornp.endereco_numero else "0"), | |
| "ORT02": re.sub(u'[^a-zA-Z0-9áéíóúÁÉÍÓÚâêîôÂÊÎÔãõÃÕçÇ: ]', '', fornp.endereco_bairro[:35]), | |
| "TELF1": fornp.fone_fixo, | |
| "SCACD": 'MEI' if fornp.tipo_sociedade == 4 else ('SIM' if fornp.anexo_simples_nacional != "0" else ""), | |
| "STGDL": ("03" if fornp.anexo_simples_nacional and fornp.anexo_simples_nacional == "3" else ""), | |
| }, | |
| "IM_IRF": { | |
| }, | |
| "IM_PARCEIRO": { | |
| } | |
| } | |
| return self.enviar_requisicao_sap(fornp, pj, pf, request_api) | |
| def atualizar_sap_tab_atividades(self, fornp: PreCadastroFornecedor, pj: PreCadastroFornecedorPj, pf: PreCadastroFornecedorPf) -> Response: | |
| # CÓDIGO SAP | |
| codigo_sap = fornp.codigo_sap | |
| # DADOS ENVIADOS NA TAB DE ATIVIDADES | |
| tipo_setor = fornp.tipo_setor | |
| tipo_sociedade = fornp.tipo_sociedade | |
| tipo_atividade = fornp.tipo_atividade | |
| tipo_prestacao_servico = fornp.tipo_prestacao_servico | |
| request_api = { | |
| "IM_BANCO": { | |
| }, | |
| "IM_EMAIL": { | |
| }, | |
| "IM_INPUT": { | |
| "LIFNR": (fornp.codigo_sap if fornp and fornp.codigo_sap else ""), | |
| # campo utilizado como flag para update | |
| }, | |
| "IM_IRF": { | |
| }, | |
| "IM_PARCEIRO": { | |
| } | |
| } | |
| return self.enviar_requisicao_sap(fornp, pj, pf, request_api) | |
| def atualizar_sap_tab_mei_pf(self, fornp: PreCadastroFornecedor, pj: PreCadastroFornecedorPj, pf: PreCadastroFornecedorPf) -> Response: | |
| # CÓDIGO SAP | |
| codigo_sap = fornp.codigo_sap | |
| # DADOS ENVIADOS NA TAB DE MEI E PF | |
| raca = fornp.raca | |
| estado_civil = fornp.estado_civil | |
| grau_instrucao = fornp.grau_instrucao | |
| pis = fornp.pis | |
| rg = fornp.rg | |
| cpf = fornp.cpf | |
| sexo = fornp.sexo | |
| pais = fornp.pais | |
| nacionalidade = fornp.nacionalidade | |
| tipo_atividade = fornp.tipo_atividade | |
| num_seq_fate = fornp.num_seq_fate | |
| tipo_prestacao_servico = fornp.tipo_prestacao_servico | |
| request_api = { | |
| "IM_BANCO": { | |
| }, | |
| "IM_EMAIL": { | |
| }, | |
| "IM_INPUT": { | |
| "LIFNR": (fornp.codigo_sap if fornp and fornp.codigo_sap else "") , # campo utilizado como flag para update | |
| "MM_PIS": pis, | |
| "MM_RACA": raca, | |
| "MM_ESTADO_CIVIL": estado_civil, | |
| "MM_CPF_MEI": cpf, | |
| "MM_SEXO": sexo, | |
| "MM_GRAU_INSTRUCAO": grau_instrucao, | |
| "MM_PAIS_NASCIMENTO": pais, | |
| "MM_PAIS_NACIONALIDADE": nacionalidade, | |
| }, | |
| "IM_IRF": { | |
| }, | |
| "IM_PARCEIRO": { | |
| } | |
| } | |
| return self.enviar_requisicao_sap(fornp, pj, pf, request_api) | |
| def atualizar_sap_tab_dados_bancarios(self, forn: PreCadastroFornecedor, pj: PreCadastroFornecedorPj, pf: PreCadastroFornecedorPf, db: PreCadDadoBancarioFnr) -> Response: | |
| # CÓDIGO SAP | |
| # DADOS ENVIADOS NA TAB DE DADOS BANCARIOS | |
| banco = lambda db: { | |
| "item": {"BANKS": db.sigla_pais, "BANKL": db.conta, "BANKN": db.conta, "KOINH": forn.nome_fantasia[:35], "BANKA": db.banco.nome, "BKONT": db.agencia_digito, }} if (db != None) else "{}" | |
| request_api = { | |
| "IM_BANCO": banco(db), | |
| "IM_EMAIL": { | |
| }, | |
| "IM_INPUT": { | |
| "LIFNR": (forn.codigo_sap if forn and forn.codigo_sap else "") # campo utilizado como flag para update | |
| }, | |
| "IM_IRF": { | |
| }, | |
| "IM_PARCEIRO": { | |
| } | |
| } | |
| return self.enviar_requisicao_sap(forn, pj, pf, request_api) | |
| def atualizar_sap(self, forn: PreCadastroFornecedor, pj: PreCadastroFornecedorPj, pf: PreCadastroFornecedorPf) -> Response: | |
| # reponsavel por enviar os dados de fornecedor para o sap através da integracao | |
| self.registrarLogFornecedor("atualizar_sap") | |
| is_pj = forn.indicador_pj_pf.strip() == 'PJ' | |
| request_api = { | |
| "IM_BANCO": { | |
| }, | |
| "IM_EMAIL": { | |
| "item": { | |
| "SMTP_ADDR": forn.email, | |
| "REMARK": "Principal" | |
| } | |
| }, | |
| "IM_INPUT": { | |
| "LIFNR": (forn.codigo_sap if forn and forn.codigo_sap else ""), # campo utilizado como flag para update | |
| "NAME1": forn.nome_fantasia[:35], | |
| "NAME2": "", # forn.razao_social, | |
| "SORTL": forn.nome_fantasia[:20], | |
| "STRAS": forn.endereco_logradouro[:35], | |
| "HOUSE_NUM1": (forn.endereco_numero if forn and forn.endereco_numero else "0"), | |
| "ORT02": re.sub(u'[^a-zA-Z0-9áéíóúÁÉÍÓÚâêîôÂÊÎÔãõÃÕçÇ: ]', '', forn.endereco_bairro[:35]), | |
| "ORT01": re.sub(u'[^a-zA-Z0-9áéíóúÁÉÍÓÚâêîôÂÊÎÔãõÃÕçÇ: ]', '', forn.cidade[:35]), | |
| "PSTLZ": (forn.cep if len(forn.cep) == 9 else forn.cep[:5] + "-" + forn.cep[5:9]), | |
| "REGIO": forn.uf, | |
| "LAND1": (forn.pais if forn and forn.pais else "BR"), | |
| "SPRAS": "PT", # sempre PT | |
| "TELF1": forn.fone_fixo, | |
| "REMARK": forn.observacao[:50], | |
| "KUNNR": "", | |
| "STCD3": pj.inscricao_estadual if is_pj else "", | |
| "STCD4": (pj.inscricao_municipal if is_pj and pj.inscricao_municipal else ""), | |
| "STCD2": (forn.cpf_cnpj if len(forn.cpf_cnpj) == 11 and forn.indicador_pj_pf.strip() == 'PF' else ''), | |
| "BRSCH": "0002", # forn.tipo_setor, #estava tipo, alterei para tipo_setor apenas para teste | |
| "SCACD": 'MEI' if forn.tipo_sociedade == 4 else ('SIM' if forn.anexo_simples_nacional != "0" else ""), | |
| "SFRGR": "CPOM", | |
| "STGDL": ("03" if forn.anexo_simples_nacional and forn.anexo_simples_nacional == "3" else ""), | |
| "TEL_NUMBER": forn.fone_fixo, | |
| "PAFKT": "G2", | |
| "WAERS": "BRL", # 'WAERS': 'BRL', #moeda do pedido | |
| "ERNAM": os.getenv('WSDL_USER') | |
| }, | |
| "IM_IRF": { | |
| }, | |
| "IM_PARCEIRO": { | |
| } | |
| } | |
| return self.enviar_requisicao_sap(forn, pf, pf, request_api) | |
| def inserir_sap(self, forn: PreCadastroFornecedor, pj: PreCadastroFornecedorPj, pf: PreCadastroFornecedorPf, db: PreCadDadoBancarioFnr) -> Response: | |
| self.registrarLogFornecedor("sincronizar_sap") | |
| is_pj = forn.indicador_pj_pf.strip() == 'PJ' | |
| banco = lambda db: {"item": { "BANKS": db.sigla_pais, "BANKL": db.conta,"BANKN": db.conta , "KOINH": forn.nome_fantasia[:35], "BANKA": db.banco.nome, "BKONT": db.agencia_digito, }} if (db != None) else "{}" | |
| request_api = { | |
| "IM_BANCO": banco(db) , | |
| "IM_EMAIL": { | |
| "item": { | |
| "SMTP_ADDR": forn.email, | |
| "REMARK": "Principal" | |
| } | |
| }, | |
| "IM_INPUT": { | |
| "LIFNR": "", # campo utilizado como flag para update | |
| "KTOKK": (1000 if forn.indicador_pj_pf.strip() == 'PJ' else 2000), | |
| "NAME1": forn.nome_fantasia[:35], | |
| "NAME2": "", # forn.razao_social, | |
| "SORTL": forn.nome_fantasia[:20], | |
| "STRAS": forn.endereco_logradouro[:35], | |
| "HOUSE_NUM1": (forn.endereco_numero if forn and forn.endereco_numero else "0"), | |
| "ORT02": re.sub(u'[^a-zA-Z0-9áéíóúÁÉÍÓÚâêîôÂÊÎÔãõÃÕçÇ: ]', '', forn.endereco_bairro[:35]), | |
| "ORT01": re.sub(u'[^a-zA-Z0-9áéíóúÁÉÍÓÚâêîôÂÊÎÔãõÃÕçÇ: ]', '', forn.cidade[:35]), | |
| "PSTLZ": (forn.cep if len(forn.cep) == 9 else forn.cep[:5] + "-" + forn.cep[5:9]), | |
| "REGIO": forn.uf, | |
| "LAND1": (forn.pais if forn and forn.pais else "BR"), | |
| "SPRAS": "PT", # sempre PT | |
| "TELF1": forn.fone_fixo, | |
| "REMARK": forn.observacao[:50], | |
| "KUNNR": "", | |
| "STCD1": (forn.cpf_cnpj if len(forn.cpf_cnpj) == 14 and is_pj else ""), | |
| "STCD3": pj.inscricao_estadual if is_pj else "", | |
| "STCD4": (pj.inscricao_municipal if is_pj and pj.inscricao_municipal else ""), | |
| "STCD2": (forn.cpf_cnpj if len(forn.cpf_cnpj) == 11 and forn.indicador_pj_pf.strip() == 'PF' else ''), | |
| "BRSCH": "0002", # forn.tipo_setor, #estava tipo, alterei para tipo_setor apenas para teste | |
| "SCACD": 'MEI' if forn.tipo_sociedade == 4 else ('SIM' if forn.anexo_simples_nacional != "0" else ""), | |
| "SFRGR": "CPOM", | |
| "STGDL": ("03" if forn.anexo_simples_nacional and forn.anexo_simples_nacional == "3" else ""), | |
| "NAMEV": geral_util.obter_nome(forn.nome_responsavel_cadastro)[:35], | |
| "NAMES": geral_util.obter_sobrenome(forn.nome_responsavel_cadastro)[:35], | |
| "TEL_NUMBER": forn.fone_fixo, | |
| "PAFKT": "G2", | |
| "BUKRS_DE": "1000", | |
| "BUKRS_ATE": "9998", | |
| "WAERS": "BRL", # 'WAERS': 'BRL', #moeda do pedido | |
| "ERNAM": os.getenv('WSDL_USER'), | |
| "QLAND": "508" | |
| }, | |
| "IM_IRF": { | |
| }, | |
| "IM_PARCEIRO": { | |
| } | |
| } | |
| return self.enviar_requisicao_sap(forn, pj, pf, request_api) | |
| def enviar_requisicao_sap(self, forn: PreCadastroFornecedor, pj: PreCadastroFornecedorPj, pf: PreCadastroFornecedorPf, request_api): | |
| self.registrarLogFornecedor('request_api:\n' + str(request_api)) | |
| try: | |
| # tem_codigo_sap = geral_util.ok(forn.codigo_sap) | |
| self.registrarLogFornecedor("Carregando wsdl_fornecedores.wsdl") | |
| session = Session() | |
| session.auth = HTTPBasicAuth(os.getenv('WSDL_USER'), os.getenv('WSDL_SENHA')) | |
| client = Client('copel/wsdl_fornecedores.wsdl', transport=Transport(session=session)) | |
| result = client.service.Inb_Sync_MM_CadastroFornecedor_PFN_Req(**request_api) | |
| self.registrarLogFornecedor("Obtendo retorno Inb_Sync_MM_CadastroFornecedor_PFN_Req") | |
| self.registrarLogFornecedor(str(result)) | |
| if result.CODIGO and result.CODIGO == '99':#se retornar 99, significa validcao por parte do sap | |
| self.registrarLogFornecedor("result.CODIGO: " + str(result.CODIGO)) | |
| if result.MSG_ERRO and result.LIFNR == None: # se existir apenas erro e não existir codigo sap, signfica validacao ou erro | |
| self.registrarLogFornecedor("result.MSG_ERRO: " + str(result.MSG_ERRO)) | |
| return api_util.HttpErroInterno(result.CODIGO + ': ' + result.MSG_ERRO) | |
| elif result.LIFNR: # caso tenha o código sap, provavelmente o fornecedor já exista e o sap irá retornar o código do fornecedor | |
| forn.codigo_sap = result.LIFNR # setando o código sap dentro do fornecedor | |
| self.registrarLogFornecedor("Atualizando código SAP no banco de dados") | |
| forn = api_util.atualizar_dados_sap(forn, model_util.DICT_SAP_FORNECEDOR, result) | |
| forn.save() | |
| return self.atualizar_sap_tab_cadastro(forn, pj, pf) | |
| else: | |
| self.registrarLogFornecedor("result.MSG_ERRO: Deve ser none") | |
| return api_util.HttpErroInterno(result.CODIGO + ': mensagem não localizada SAP') | |
| if result.CODIGO and result.CODIGO == '00' and result.LIFNR: # se for codigo 00, significa que o fornecedor foi cadastrado/atualiado no sap | |
| forn.codigo_sap = result.LIFNR | |
| self.registrarLogFornecedor("result.CODIGO: " + str(result.CODIGO)) | |
| self.registrarLogFornecedor("result.MSG_SUCESSO: " + str(result.MSG_ERRO)) | |
| self.registrarLogFornecedor("result.LIFNR: " + str(result.LIFNR)) | |
| # if not tem_codigo_sap: | |
| # self.registrarLogFornecedor("Atualizando código SAP no banco de dados") | |
| # forn = api_util.atualizar_dados_sap(forn, model_util.DICT_SAP_FORNECEDOR, result) | |
| # forn.save() | |
| # else: | |
| # self.registrarLogFornecedor("NÃO atualiza código SAP, pois ele já existia ") | |
| dados = self.serializer_class(forn).data | |
| self.registrarLogFornecedor("Resposta: sap final ok ") | |
| return api_util.HttpOK(dados) | |
| except Exception as exc: | |
| self.registrarLogFornecedor("Exception") | |
| self.registrarLogFornecedor(str(exc)) | |
| # verificacao da falha ao enviar os dados para o sap | |
| self.handle_exception(exc) | |
| return api_util.HttpErroInterno(str(exc)) | |
| def validar_dados_obrigatorios_sap(self, forn: PreCadastroFornecedor, pj: PreCadastroFornecedorPj): | |
| if not geral_util.ok(forn.email): | |
| return False, 'email' | |
| if not geral_util.ok(forn.indicador_pj_pf): | |
| return False, 'indicador_pj_pf' | |
| is_pj = forn.indicador_pj_pf.strip() == 'PJ' | |
| if is_pj and not geral_util.ok(pj.inscricao_estadual): | |
| return False, 'inscricao_estadual' | |
| if is_pj and not geral_util.ok(forn.nome_responsavel_cadastro): | |
| return False, 'nome_responsavel_cadastro' | |
| if not geral_util.ok(forn.nome_fantasia): | |
| return False, 'nome_fantasia' | |
| if not geral_util.ok(forn.endereco_logradouro): | |
| return False, 'endereco_logradouro' | |
| if not geral_util.ok(forn.endereco_bairro): | |
| return False, 'endereco_bairro' | |
| if not geral_util.ok(forn.cidade): | |
| return False, 'cidade' | |
| if not geral_util.ok(forn.cep): | |
| return False, 'cep' | |
| if not geral_util.ok(forn.uf): | |
| return False, 'uf' | |
| if not geral_util.ok(forn.fone_fixo): | |
| return False, 'fone_fixo' | |
| if not geral_util.ok(forn.cpf_cnpj): | |
| return False, 'cpf_cnpj' | |
| if not geral_util.ok(forn.anexo_simples_nacional): | |
| return False, 'anexo_simples_nacional' | |
| return True, None | |
| class FornecedorPreCadastroView(viewsets.ModelViewSet): | |
| serializer_class = FornecedorSerialized | |
| search_fields = ['nome_fantasia', 'cpf_cnpj', 'nome_responsavel_cadastro'] | |
| filter_backends = [SearchFilter] | |
| queryset = PreCadastroFornecedor.objects.all().order_by('nome_fantasia') | |
| http_method_names = ['post', 'options'] | |
| authentication_classes = [] | |
| def update(self, request, *args, **kwargs): | |
| raise Exception('Fornecedor não pode ser atualizado por esse path') | |
| def destroy(self, request, *args, **kwargs): | |
| raise Exception('Fornecedor não pode ser deletado por esse path') | |
| def get_queryset(self): | |
| situacao = self.request.query_params.get('situacao') | |
| etapa = self.request.query_params.get('etapa') | |
| if situacao: | |
| situacao = situacao.replace('/', '') | |
| if etapa: | |
| etapa = etapa.replace('/', '') | |
| if situacao and etapa: | |
| queryset = PreCadastroFornecedor.objects.filter(situacao_cadastro=situacao, etapa_cadastro=etapa).order_by( | |
| 'nome_fantasia') | |
| elif situacao: | |
| queryset = PreCadastroFornecedor.objects.filter(situacao_cadastro=situacao).order_by('nome_fantasia') | |
| elif etapa: | |
| queryset = PreCadastroFornecedor.objects.filter(etapa_cadastro=etapa).order_by('nome_fantasia') | |
| else: | |
| queryset = PreCadastroFornecedor.objects.all().order_by('nome_fantasia') | |
| return queryset | |
| def listar_tipo_atividades(self, request: Request) -> Response: | |
| lista = [] | |
| lista.append({'id': 0, 'nome': 'Prestador de serviços'}) | |
| lista.append({'id': 1, 'nome': 'Fornecedor de materiais'}) | |
| return api_util.HttpOK(lista) | |
| def status(self, request: Request, cnpj) -> Response: | |
| objects = PreCadastroFornecedor.objects.filter(cpf_cnpj=cnpj)[0:1] | |
| dados = self.serializer_class(objects, many=True).data | |
| if len(dados) == 0: | |
| return api_util.HttpOK("ERRO: Não existe um fornecedor com o cnpj: " + cnpj) | |
| return api_util.HttpOK(str(dados[0]['etapa_cadastro'])) | |
| class DocumentoVinculoView(viewsets.ModelViewSet): | |
| parser_classes = (MultiPartParser, FormParser) | |
| serializer_class = DocumentoVinculoSerialized | |
| filter_backends = [SearchFilter] | |
| queryset = DocumentoVinculadoFornecedor.objects.all() | |
| def create(self, request, *args, **kwargs): | |
| raise Exception('Documentos não são criados nesse endpoint') | |
| def enviar_conteudo_documento(self, request: Request): | |
| json = request.data | |
| id_tipo_documento = json['documento_id'] | |
| fornecedor_id = json['fornecedor_id'] if 'fornecedor_id' in json else None | |
| numero_contrato = json['numero_contrato'] if 'numero_contrato' in json else None | |
| id_dvf = json['dvf_id'] if 'dvf_id' in json else None | |
| arquivo = json['url'].file.read() | |
| nome = json['url'].name | |
| return self.enviar_conteudo_documento_stg(id_dvf, id_tipo_documento, fornecedor_id, numero_contrato, arquivo, | |
| nome, 'P') | |
| def enviar_conteudo_documento_v2(self, request: Request, fornecedor_id, label_tipo_doc) -> Response: | |
| try: | |
| id_tipo_documento = tipo_documento_util.obter_id_por_label(label_tipo_doc) | |
| arquivo = request.read() | |
| nome = label_tipo_doc + '.pdf' | |
| id_dvf = None | |
| return self.enviar_conteudo_documento_stg(id_dvf, id_tipo_documento, fornecedor_id, None, arquivo, nome, | |
| 'R', label_tipo_doc) | |
| except Exception as e: | |
| return api_util.HttpErroInterno('ERRO NO V2: ' + str(e)) | |
| def enviar_conteudo_documento_stg(self, id_dvf, id_tipo_documento, fornecedor_id, numero_contrato, arquivo, nome, | |
| enviado_por, label_tipo_doc='sem_label'): | |
| if id_dvf is not None: | |
| dvf = DocumentoVinculadoFornecedor.objects.get(pk=id_dvf) | |
| else: | |
| if fornecedor_id is not None and numero_contrato is not None: | |
| raise Exception('Enviar o parâmetro fornecedor_id ou numero_contrato') | |
| if fornecedor_id is not None: | |
| condicional = Q(documento_id=id_tipo_documento) & Q(fornecedor_id=fornecedor_id) & Q( | |
| numero_contrato__isnull=True) & Q(versao_atual=True) | |
| elif numero_contrato is not None: | |
| condicional = Q(documento_id=id_tipo_documento) & Q(numero_contrato=numero_contrato) & Q( | |
| versao_atual=True) | |
| else: | |
| raise Exception('Enviar o parâmetro fornecedor_id ou numero_contrato') | |
| dvf = DocumentoVinculadoFornecedor.objects.filter(condicional).first() | |
| if dvf is None: | |
| s_id_tipo_documento = 'None' if id_tipo_documento is None else str(id_tipo_documento) | |
| s_fornecedor = 'None' if fornecedor_id is None else str(fornecedor_id) | |
| s_numero_contrato = 'None' if numero_contrato is None else str(numero_contrato) | |
| s_dvf_id = 'None' if id_dvf is None else str(id_dvf) | |
| info_erro = 'id_dvf: ' + s_dvf_id + 'id_tipo_documento: ' + s_id_tipo_documento + ' | fornecedor_id: ' + s_fornecedor + ' | numero_contrato: ' + s_numero_contrato + ' | label_tipo_doc: ' + label_tipo_doc | |
| return api_util.HttpBadRequest( | |
| 'Não foi encontrado um documento desse tipo para esse fornecedor: ' + info_erro) | |
| if ambiente_util.is_local_ou_dev(): | |
| if dvf.token_stg is not None and (dvf.status == 3 or dvf.status == 4): | |
| raise Exception( | |
| 'O documento já foi validado ou recusado e não pode ser alterado, crie uma nova versão de documento') | |
| status_documento = 2 | |
| arquivo_stg_dev = geral_util.obter_arquivo_stg_dev(dvf.num_seq_dovf) | |
| geral_util.salvar_bytes(arquivo_stg_dev, arquivo) | |
| dvf.token_stg = 'SALVO_DEV' | |
| dvf.enviado_por = enviado_por | |
| dvf.status = status_documento | |
| dvf.save() | |
| documento_ng.tratar_despacho_alteracao_status(dvf, status_documento, '') | |
| resultado = 'OK' | |
| else: | |
| resultado = integracao.stg_enviar_arquivo(arquivo, nome, dvf=dvf, enviado_por=enviado_por) | |
| if resultado == 'OK': | |
| return api_util.HttpOK('OK') | |
| else: | |
| return api_util.HttpErroInterno(resultado) | |
| def stg_download(self, request: Request, codigo_doc) -> Response: | |
| if ambiente_util.is_local_ou_dev(): | |
| arquivo_stg_dev = geral_util.obter_arquivo_stg_dev(codigo_doc) | |
| arquivo = geral_util.obter_bytes(arquivo_stg_dev) | |
| else: | |
| arquivo = integracao.stg_download_arquivo(codigo_doc) | |
| if type(arquivo) is str: | |
| return api_util.HttpErroInterno(arquivo) | |
| http_res = HttpResponse(arquivo, content_type='application/pdf') | |
| http_res['Content-Disposition'] = 'attachment; filename=arquivo.pdf' | |
| http_res['Content-Length'] = len(arquivo) | |
| http_res['Access-Control-Allow-Origin'] = '*' | |
| http_res['Access-Control-Allow-Methods'] = 'DELETE, GET, OPTIONS, PATCH, POST, PUT' | |
| http_res[ | |
| 'Access-Control-Allow-Headers'] = 'accept, accept-encoding, authorization, content-type, dnt, origin, user-agent, x-csrftoken, x-requested-with' | |
| http_res['Access-Control-Allow-Age'] = '86400' | |
| return http_res | |
| def nome_arquivo(self, request: Request) -> Response: | |
| caminho = os.path.abspath('copel/wsdl_contratos.wsdl') | |
| return api_util.HttpOK(caminho + ' - existe = ' + str(os.path.isfile('copel/wsdl_contratos.wsdl'))) | |
| def contar_documentos_pendentes(self, request: Request, fornecedor_id) -> Response: | |
| qtd = fornecedor_ps.contar_documentos_pendentes(fornecedor_id) | |
| return api_util.HttpOK(str(qtd)) | |
| def contar_contratos_com_documentos_pendentes(self, request: Request, fornecedor_id) -> Response: | |
| qtd = fornecedor_ps.contar_contratos_com_documentos_pendentes(fornecedor_id) | |
| return api_util.HttpOK(str(qtd)) | |
| def contar_contratos_ativos(self, request: Request, codigo_sap) -> Response: | |
| qtd = fornecedor_ps.contar_contratos_ativos(codigo_sap) | |
| return api_util.HttpOK(str(qtd)) | |
| def listar_contratos_com_documentos_pendentes(self, request: Request, fornecedor_id) -> Response: | |
| lista = fornecedor_ps.listar_contratos_com_documentos_pendentes(fornecedor_id) | |
| return api_util.HttpOK(lista) | |
| def montar_retorno_contrato_fornecedor(self, lista_pag) -> Response: | |
| lista = [] | |
| for dado in lista_pag['data']: | |
| lista.append({'contrato': dado['contrato'], 'fornecedor_id': dado['fornecedor_id']}) | |
| lista_final = [] | |
| lista_id_fornecedor = [] | |
| for item in lista: | |
| lista_id_fornecedor.append(item['fornecedor_id']) | |
| condicional = Q(num_seq_pcfnr__in=lista_id_fornecedor) | |
| objects = PreCadastroFornecedor.objects.filter(condicional).order_by('nome_fantasia') | |
| lista_fornecedores = FornecedorListagemSerialized(objects, many=True).data | |
| dict_idfornecedor_fornecedor = {} | |
| for fornecedor in lista_fornecedores: | |
| dict_idfornecedor_fornecedor[fornecedor['num_seq_pcfnr']] = fornecedor | |
| for item in lista: | |
| fornecedor_id = item['fornecedor_id'] | |
| numero_contrato = item['contrato'] | |
| fornecedor = dict_idfornecedor_fornecedor[fornecedor_id] | |
| dict_final = { | |
| 'contrato': {'numero_contrato': numero_contrato}, | |
| 'fornecedor': fornecedor | |
| } | |
| lista_final.append(dict_final) | |
| json = { | |
| 'metadata': lista_pag['metadata'], | |
| 'data': lista_final | |
| } | |
| return api_util.HttpOK(json) | |
| def listar_pag_contratos(self, request: Request, somente_do_gestor_logado) -> Response: | |
| offset, limit = api_util.obter_parametros_paginacao(request) | |
| filtro = api_util.obter_parametro_search(request) | |
| somente_gestor_logado = somente_do_gestor_logado.lower() == 'true' | |
| login = None | |
| if somente_gestor_logado: | |
| login = login_ng.obter_login(request) | |
| lista_pag = fornecedor_ps.listar_pag_contratos(filtro, login, offset, limit) | |
| return self.montar_retorno_contrato_fornecedor(lista_pag) | |
| def listar_pag_contratos_com_documentos_pendentes(self, request: Request, somente_do_gestor_logado) -> Response: | |
| offset, limit = api_util.obter_parametros_paginacao(request) | |
| filtro = api_util.obter_parametro_search(request) | |
| somente_gestor_logado = somente_do_gestor_logado.lower() == 'true' | |
| login = None | |
| if somente_gestor_logado: | |
| login = login_ng.obter_login(request) | |
| lista_pag = fornecedor_ps.listar_pag_contratos_com_documentos_pendente(filtro, login, offset, limit) | |
| return self.montar_retorno_contrato_fornecedor(lista_pag) | |
| def listar_pag_fornecedor_documento_pendente(self, request: Request, somente_do_gestor_logado) -> Response: | |
| offset, limit = api_util.obter_parametros_paginacao(request) | |
| filtro = api_util.obter_parametro_search(request) | |
| somente_gestor_logado = somente_do_gestor_logado.lower() == 'true' | |
| login = None | |
| if somente_gestor_logado: | |
| login = login_ng.obter_login(request) | |
| lista_pag = fornecedor_ps.listar_pag_id_fornecedor_documento_pendente_fc(filtro, login, offset, limit) | |
| lista_id = [] | |
| for dado in lista_pag['data']: | |
| lista_id.append(dado['id']) | |
| lista_fornecedores = [] | |
| if len(lista_id) > 0: | |
| condicional = Q(num_seq_pcfnr__in=lista_id) | |
| objects = PreCadastroFornecedor.objects.filter(condicional).order_by('nome_fantasia') | |
| lista_fornecedores = FornecedorListagemSerialized(objects, many=True).data | |
| json = { | |
| 'metadata': lista_pag['metadata'], | |
| 'data': lista_fornecedores | |
| } | |
| return api_util.HttpOK(json) | |
| def gerar_extrato_fornecedor(self, request: Request, fornecedor_id) -> Response: | |
| s_data = api_util.obter_parametro(request, 'data') | |
| if s_data is not None: | |
| try: | |
| data = datetime.strptime(s_data, '%Y-%m-%d') | |
| except: | |
| raise Exception("Formato de Data inválido") | |
| extrato = extrato_fornecedor_ng.consultar_extrato(fornecedor_id, data) | |
| if extrato is not None: | |
| extrato = geral_util.to_string(extrato) | |
| extrato = json_api.loads(extrato) | |
| else: | |
| extrato = extrato_fornecedor_ng.gerar_extrato(fornecedor_id) | |
| if extrato is None: | |
| return api_util.HttpBadRequest('Não existe histórico nessa data para esse fornecedor') | |
| return api_util.HttpOK(extrato) | |
| # Gera lista de extrato de todos fornecedores, ou dos fornecedores que atendam ao filtro | |
| def gerar_extrato_fornecedores(self, request: Request) -> Response: | |
| offset, limit = api_util.obter_parametros_paginacao(request) | |
| filtro = api_util.obter_parametro_search(request) | |
| fornecedores = fornecedor_ps.listar_id_fornecedores(filtro=filtro, offset=offset, limit=limit) | |
| extratos = [] | |
| for fornecedor in fornecedores['data']: | |
| extrato = extrato_fornecedor_ng.gerar_extrato(fornecedor['id']) | |
| extrato[0]['id_fornecedor'] = fornecedor['id'] | |
| extrato[0]['codigo_sap'] = fornecedor['codigo_sap'] | |
| extrato[0]['cpf_cnpj'] = fornecedor['cpf_cnpj'] | |
| extratos.append(extrato) | |
| json = { | |
| 'metadata': fornecedores['metadata'], | |
| 'data': extratos | |
| } | |
| return api_util.HttpOK(json) | |
| def notificar_pendencias_contrato(self, request, num_contrato): | |
| fornecedor_ng.preparar_notificacao_pendencias_contrato(num_contrato) | |
| return api_util.HttpOK('Pendencia Notificada.') | |
| class FornecedorVincularGrupoDocumentoView(viewsets.ViewSet): | |
| def salvar_datas(self, request: Request, documento_id): | |
| json = request.data | |
| dvf = DocumentoVinculadoFornecedor.objects.get(num_seq_dovf=documento_id) | |
| if dvf is None: | |
| return api_util.HttpBadRequest('Não foi encontrado um documento com esse id: ' + str(documento_id)) | |
| dvf.dt_validade = geral_util.to_date_django(json['dt_validade']) | |
| dvf.dt_emissao = geral_util.to_date_django(json['dt_emissao']) | |
| dvf.save() | |
| return api_util.HttpOK('OK') | |
| def salvar_status(self, request: Request, documento_id, status): | |
| json = request.data | |
| dvf = DocumentoVinculadoFornecedor.objects.get(num_seq_dovf=documento_id) | |
| if dvf is None: | |
| return api_util.HttpBadRequest('Não foi encontrado um documento com esse id: ' + str(documento_id)) | |
| descricao_adicional = json['corpo_email_adicional'] if 'corpo_email_adicional' in json else '' | |
| if status == 4 and descricao_adicional != '': | |
| dvf.justificativa_recusa = descricao_adicional | |
| dvf.status = status | |
| dvf.save() | |
| corpo_email_adicional = json['corpo_email_adicional'] if 'corpo_email_adicional' in json else '' | |
| documento_ng.tratar_despacho_alteracao_status(dvf, status, corpo_email_adicional) | |
| return api_util.HttpOK('OK') |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment