transdesk-importer-python-sdk 1.0.0__py3-none-any.whl

transdesk/importer/transformers/canonical/apolice_builder.py

@@ -0,0 +1,272 @@
+from collections import defaultdict
+
+from transdesk.importer.models.canonical import (
+    CanonicalItem,
+    CanonicalPolicy,
+    Cliente,
+    Complemento,
+    DadosBancarios,
+    Endereco,
+    ReboqueRisco,
+    Subestipulante,
+    UnidadeVenda,
+    VeiculoRisco,
+    VidaRisco,
+)
+from transdesk.importer.shared.data_normalizer import DataNormalizer
+from transdesk.importer.transformers.canonical.item_classifier import ItemClassifier
+from transdesk.importer.transformers.canonical.cobertura_builder import CoberturaBuilder
+
+
+class ApoliceBuilder:
+
+    def build(self, df):
+        grouped = self.group_by_apolice(df)
+
+        return [
+            self.build_apolice(cod_apolice, rows)
+            for cod_apolice, rows in grouped.items()
+        ]
+
+    def group_by_apolice(self, df):
+        grouped = defaultdict(list)
+
+        for _, row in df.iterrows():
+            grouped[str(row["COD_AGRUPADOR_APOLICE"])].append(row)
+
+        return grouped
+
+    def build_apolice(self, cod_apolice, rows):
+        first_row = rows[0]
+        return CanonicalPolicy(
+            cod_agrupador_apolice=int(cod_apolice),
+            dia_vencimento=DataNormalizer.to_int(first_row.get("DIA_VCTO")),
+            subestipulante=self.build_subestipulante(first_row),
+            cliente=self.build_cliente(first_row),
+            unidade_venda=self.build_unidade_venda(first_row),
+            itens=self.build_itens(rows),
+        )
+
+    # ---------------------------------------------------------
+    # CLIENTE
+    # ---------------------------------------------------------
+
+    def build_cliente(self, row):
+        return Cliente(
+            matricula=row.get("MATRICULA_CLIENTE"),
+            tipo_pessoa=row.get("PESSOA"),
+            documento=DataNormalizer.clean_doc(row.get("CNPJ_CPF_CLIENTE")),
+            nome_fantasia=row.get("NOME_FANTASIA_CLIENTE"),
+            razao_social=row.get("RAZAO_SOCIAL_CLIENTE"),
+            telefones=[
+                row.get("FONE1_CLIENTE"),
+                row.get("FONE2_CLIENTE"),
+            ],
+            emails=[
+                row.get("EMAIL_CLIENTE"),
+            ],
+            endereco=Endereco(
+                cep=row.get("CEP_CLIENTE"),
+                logradouro=row.get("ENDERECO_CLIENTE"),
+                numero=row.get("NUMERO_ENDERECO_CLIENTE"),
+                complemento=row.get("COMPLEMENTO_ENDERECO_CLIENTE"),
+                bairro=row.get("BAIRRO_ENDERECO_CLIENTE"),
+                cidade=row.get("CIDADE_ENDERECO_CLIENTE"),
+                uf=row.get("UF_ENDERECO_CLIENTE"),
+            ),
+            dados_bancarios=DadosBancarios(
+                banco=row.get("BANCO"),
+                agencia=row.get("AGENCIA"),
+                conta=row.get("CONTA"),
+                chave_pix=row.get("CHAVE_PIX"),
+                titular=row.get("TITULAR"),
+                documento_titular=DataNormalizer.clean_doc(row.get("CNPJ_CPF_TITULAR")),
+            ),
+        )
+
+    # ---------------------------------------------------------
+    # SUBESTIPULANTE
+    # ---------------------------------------------------------
+
+    def build_subestipulante(self, row):
+        return Subestipulante(
+            id_unity=row.get("ID_UNITY"),
+            documento=DataNormalizer.clean_doc(row.get("SUB_ESTIPULANTE_CNPJ")),
+            nome_fantasia=row.get("SUB_ESTIPULANTE_FANTASIA"),
+            razao_social=row.get("SUB_ESTIPULANTE_RAZAO_SOCIAL"),
+        )
+
+    # ---------------------------------------------------------
+    # UNIDADE VENDA
+    # ---------------------------------------------------------
+
+    def build_unidade_venda(self, row):
+        return UnidadeVenda(
+            documento=DataNormalizer.clean_doc(row.get("CNPJ_CPF_UNIDADE_VENDA")),
+            nome_fantasia=row.get("NOME_FANTASIA_UNIDADE_VENDA"),
+            razao_social=row.get("RAZAO_SOCIAL_UNIDADE_VENDA"),
+        )
+
+    # ---------------------------------------------------------
+    # ITENS
+    # ---------------------------------------------------------
+
+    def build_itens(self, rows):
+        grouped = defaultdict(list)
+
+        for row in rows:
+            key = self.build_item_key(row)
+            grouped[key].append(row)
+
+        return [
+            self.build_item(item_rows)
+            for item_rows in grouped.values()
+        ]
+
+    def build_item_key(self, row):
+        if ItemClassifier.is_vida(row):
+            return (
+                f"VIDA|"
+                f"{row.get('CPF_SEGURADO_SEGURO_VIDA')}"
+            )
+
+        if ItemClassifier.is_reboque(row):
+            return (
+                f"REBOQUE|"
+                f"{row.get('PLACA_VEICULO')}|"
+                f"{row.get('CHASSI')}|"
+                f"{row.get('MARCA_REBOQUE')}|"
+                f"{row.get('MODELO_REBOQUE')}"
+            )
+
+        return (
+            f"VEICULO|"
+            f"{row.get('PLACA_VEICULO')}|"
+            f"{row.get('CHASSI')}"
+        )
+
+    def build_item(self, rows):
+        row = rows[0]
+
+        if ItemClassifier.is_vida(row):
+            return self.build_vida(rows)
+
+        if ItemClassifier.is_reboque(row):
+            return self.build_reboque(rows)
+
+        return self.build_veiculo(rows)
+
+    # ---------------------------------------------------------
+    # VIDA
+    # ---------------------------------------------------------
+
+    def build_vida(self, rows):
+        row = rows[0]
+
+        return CanonicalItem(
+            tipo_item="vida",
+            dados_risco=VidaRisco(
+                nome=row.get("NOME_SEGURADO_SEGURO_VIDA"),
+                cpf=DataNormalizer.clean_doc(row.get("CPF_SEGURADO_SEGURO_VIDA")),
+                rg=row.get("RG_SEGURADO_SEGURO_VIDA"),
+                data_nascimento=row.get("DATE_BIRTH_SEGURADO_SEGURO_VIDA"),
+            ),
+            coberturas=CoberturaBuilder(rows).build(),
+        )
+
+    # ---------------------------------------------------------
+    # REBOQUE
+    # ---------------------------------------------------------
+
+    def build_reboque(self, rows):
+        row = rows[0]
+
+        return CanonicalItem(
+            tipo_item="reboque",
+            dados_risco=ReboqueRisco(
+                placa=row.get("PLACA_VEICULO"),
+                chassi=row.get("CHASSI"),
+                marca=row.get("MARCA_REBOQUE"),
+                modelo=row.get("MODELO_REBOQUE"),
+            ),
+            coberturas=CoberturaBuilder(rows).build(),
+        )
+
+    # ---------------------------------------------------------
+    # VEICULO
+    # ---------------------------------------------------------
+
+    def build_veiculo(self, rows):
+        row = rows[0]
+
+        item = CanonicalItem(
+            tipo_item="veiculo",
+            dados_risco=VeiculoRisco(
+                placa=row.get("PLACA_VEICULO"),
+                chassi=row.get("CHASSI"),
+                codigo_fipe=row.get("CODE_FIPE"),
+            ),
+            complementos=self.build_complementos(rows),
+            coberturas=CoberturaBuilder(rows).build(),
+        )
+
+        self.merge_complement_coverages(item)
+
+        return item
+
+    # ---------------------------------------------------------
+    # COMPLEMENTOS
+    # ---------------------------------------------------------
+
+    def build_complementos(self, rows):
+        complementos = {}
+
+        for row in rows:
+            descricao = row.get("COMPLEMENT_DESCRIPTION")
+
+            if not descricao:
+                continue
+
+            importancia = DataNormalizer.to_float(row.get("IMPORTANCIA_SEGURADA"))
+
+            key = (descricao, importancia)
+
+            if key not in complementos:
+                complementos[key] = Complemento(
+                    descricao=descricao,
+                    franquia=DataNormalizer.to_float(row.get("FRANQUIA")),
+                    importancia_segurada=importancia,
+                )
+
+        return list(complementos.values())
+
+    # ---------------------------------------------------------
+    # COMPLEMENTO -> VEICULO
+    # ---------------------------------------------------------
+
+    def merge_complement_coverages(self, item):
+        casco_extra = 0
+        reparo_extra = 0
+
+        novas = []
+
+        for c in item.coberturas:
+            nome = c.nome
+
+            if nome == "Casco PT (COMPLEMENTO)":
+                casco_extra += (c.valor_mensalidade or 0)
+                continue
+
+            if nome == "Assistência a Reparos (COMPLEMENTO)":
+                reparo_extra += (c.valor_mensalidade or 0)
+                continue
+
+            novas.append(c)
+
+        for c in novas:
+            if c.nome == "Casco PT (VEÍCULO)":
+                c.valor_mensalidade = ((c.valor_mensalidade or 0) + casco_extra)
+            elif c.nome == "Assistência a Reparos (VEÍCULO)":
+                c.valor_mensalidade = ((c.valor_mensalidade or 0) + reparo_extra)
+
+        item.coberturas = novas

transdesk/importer/transformers/canonical/cobertura_builder.py

@@ -0,0 +1,39 @@
+from transdesk.importer.models.canonical import Cobertura
+from transdesk.importer.shared.data_normalizer import DataNormalizer
+
+
+class CoberturaBuilder:
+
+    def __init__(self, rows):
+        self.rows = rows
+
+    def build_key(self, row):
+        return "|".join([
+            row.get("NME_BENEFICIO", ""),
+            row.get("PRODUTO", ""),
+            row.get("NME_CATEGORIA", ""),
+            row.get("TIPO_CATEGORIA", ""),
+        ])
+
+    def build(self):
+        coverages = {}
+
+        for row in self.rows:
+            key = self.build_key(row)
+
+            if key not in coverages:
+                coverages[key] = Cobertura(
+                    nome=row.get("NME_BENEFICIO"),
+                    tipo=row.get("TIPO"),
+                    combo=row.get("COMBO"),
+                    produto=row.get("PRODUTO"),
+                    categoria=row.get("NME_CATEGORIA"),
+                    tipo_categoria=row.get("TIPO_CATEGORIA"),
+                    codigo_tabela=row.get("TABELA_PRECO"),
+                    franquia=DataNormalizer.to_float(row.get("FRANQUIA")),
+                    importancia_segurada=DataNormalizer.to_float(row.get("IMPORTANCIA_SEGURADA")),
+                    valor_mensalidade=DataNormalizer.to_float(row.get("VALOR_MENSALIDADE")),
+                    observacao=row.get("OBS"),
+                )
+
+        return list(coverages.values())

transdesk/importer/transformers/canonical/item_classifier.py

@@ -0,0 +1,22 @@
+class ItemClassifier:
+
+    @staticmethod
+    def is_vida(row):
+        return bool(
+            row.get("NOME_SEGURADO_SEGURO_VIDA")
+        )
+
+    @staticmethod
+    def is_reboque(row):
+        return (
+            bool(row.get("PLACA_VEICULO"))
+            and bool(row.get("CHASSI"))
+            and bool(row.get("MARCA_REBOQUE"))
+            and bool(row.get("MODELO_REBOQUE"))
+        )
+
+    @staticmethod
+    def is_complemento(row):
+        return bool(
+            row.get("COMPLEMENT_DESCRIPTION")
+        )

transdesk/importer/transformers/internal/__init__.py

@@ -0,0 +1,6 @@
+from .coverage_mapper import CoverageMapper
+from .internal_mapper import InternalMapper
+from .rcf_parser import RCFParser
+from .towing_parser import TowingParser
+
+__all__ = ["CoverageMapper", "InternalMapper", "RCFParser", "TowingParser"]

transdesk/importer/transformers/internal/coverage_mapper.py

@@ -0,0 +1,138 @@
+from transdesk.importer.models.internal import InternalItem
+from transdesk.importer.transformers.internal.rcf_parser import RCFParser
+from transdesk.importer.transformers.internal.towing_parser import TowingParser
+
+
+class CoverageMapper:
+
+    def __init__(self):
+        self.rcf_parser = RCFParser()
+        self.towing_parser = TowingParser()
+
+    def apply_all(self, item: InternalItem, coberturas):
+        for coverage in coberturas:
+            self.apply_coverage(item, coverage)
+
+        return item
+
+    def apply_coverage(self, item: InternalItem, coverage):
+        name = coverage.nome
+
+        if coverage.combo:
+            item.group_name = coverage.combo
+
+        if name in (
+            "Casco PT (VEÍCULO)",
+            "Casco PT (R/SR)",
+        ):
+            self._apply_casco(item, coverage)
+
+        elif name == "Casco PT (COMPLEMENTO)":
+            self._apply_body(item, coverage)
+
+        elif name in (
+            "Assistência a Reparos (VEÍCULO)",
+            "Assistência a Reparos (R/SR)",
+        ):
+            self._apply_repair(item, coverage)
+
+        elif name == "Assistência a Reparos (COMPLEMENTO)":
+            self._apply_body(item, coverage)
+
+        elif name == "RCF":
+            self._apply_rcf(item, coverage)
+
+        elif name == "APP":
+            self._apply_app(item, coverage)
+
+        elif name in (
+            "Assistência 24 Horas",
+            "Assistência 24 horas - AVULSO",
+        ):
+            self._apply_towing(item, coverage)
+
+        elif name == "Assistência a Vidros":
+            self._apply_glass(item, coverage)
+
+        elif name in (
+            "Rastreador p/ Veículo",
+            "Rastreador p/ Reboque",
+            "SUPORTE EMERGENCIAL MONITORADO",
+        ):
+            self._apply_tracker(item, coverage)
+
+        elif name == "Assistência Jurídica":
+            self._apply_legal_assistance(item, coverage)
+
+    def _apply_casco(self, item, coverage):
+        item.has_casco_cir = True
+        item.hull_value += (coverage.importancia_segurada or 0)
+        item.hull_premium += (coverage.valor_mensalidade or 0)
+
+    def _apply_repair(self, item, coverage):
+        item.has_repair_assistance = True
+        item.repair_assistance_value += (coverage.importancia_segurada or 0)
+        item.repair_assistance_premium += (coverage.valor_mensalidade or 0)
+
+    def _apply_body(self, item, coverage):
+        item.body_value += (coverage.importancia_segurada or 0)
+        item.body_premium += (coverage.valor_mensalidade or 0)
+
+    def _apply_app(self, item, coverage):
+        item.has_app = True
+        item.personal_accident_coverage_value = (coverage.importancia_segurada or 0)
+        item.personal_accident_coverage_premium = (coverage.valor_mensalidade or 0)
+
+    def _apply_legal_assistance(self, item, coverage):
+        item.has_legal_assistance = True
+        item.legal_assistance_value = 1
+        item.legal_assistance_premium += (coverage.valor_mensalidade or 0)
+
+    def _apply_tracker(self, item, coverage):
+        item.has_vehicle_tracker = True
+        item.vehicle_tracker_premium += (coverage.valor_mensalidade or 0)
+
+    def _apply_glass(self, item, coverage):
+        item.glass_coverage_type = "completo"
+        item.glass_premium += (coverage.valor_mensalidade or 0)
+
+    def _apply_rcf(self, item, coverage):
+        item.has_rcf = True
+
+        parsed = self.rcf_parser.parse(coverage.produto)
+
+        premiums = self._allocate_premium(
+            coverage.valor_mensalidade or 0,
+            {
+                "property_damage": parsed["property_damage_value"],
+                "bodily_injury": parsed["bodily_injury_value"],
+                "moral_damage": parsed["moral_damage_value"],
+            },
+        )
+
+        item.property_damage_value += (parsed["property_damage_value"])
+        item.property_damage_premium += (premiums["property_damage"])
+
+        item.bodily_injury_value += (parsed["bodily_injury_value"])
+        item.bodily_injury_premium += (premiums["bodily_injury"])
+
+        item.moral_damage_value += (parsed["moral_damage_value"])
+        item.moral_damage_premium += (premiums["moral_damage"])
+
+    def _apply_towing(self, item, coverage):
+        km = self.towing_parser.parse(coverage.produto)
+
+        item.towing_km += km
+        item.towing_premium += (coverage.valor_mensalidade or 0)
+
+    def _allocate_premium(self, total_premium, values):
+        total_premium = total_premium or 0
+        total = sum(values.values())
+
+        if total == 0:
+            return {key: 0 for key in values}
+
+        return {
+            key: (total_premium * value / total)
+            for key, value in values.items()
+        }

transdesk/importer/transformers/internal/internal_mapper.py

@@ -0,0 +1,176 @@
+from transdesk.importer.models.internal import (
+    Address,
+    Broker,
+    CustomerInfo,
+    InternalItem,
+    InternalPolicy,
+    Lead,
+    Mobile,
+    PolicyData,
+    ResellerData,
+    Telephone,
+)
+from transdesk.importer.transformers.internal.coverage_mapper import CoverageMapper
+
+
+class InternalMapper:
+
+    def __init__(self):
+        self.coverage_mapper = CoverageMapper()
+
+    def map(self, policy) -> InternalPolicy:
+        return InternalPolicy(
+            reference_id=str(policy.cod_agrupador_apolice),
+            payment_due_date=policy.dia_vencimento,
+            data=PolicyData(
+                reseller=ResellerData(broker=self.build_broker(policy)),
+                lead=self.build_lead(policy),
+                items=self.build_items(policy),
+            ),
+            original_data=policy,
+        )
+
+    def build_broker(self, policy) -> Broker:
+        broker = policy.subestipulante
+
+        return Broker(
+            internal_code=broker.id_unity,
+            document_number=broker.documento,
+            principal_name=broker.nome_fantasia,
+            secondary_name=broker.razao_social,
+        )
+
+    def build_lead(self, policy) -> Lead:
+        customer = policy.cliente
+
+        email = next((e for e in customer.emails if e), None)
+
+        return Lead(
+            customer_info=CustomerInfo(
+                cnpj=customer.documento,
+                principal_name=(customer.razao_social or customer.nome_fantasia),
+                secondary_name="",
+                email_address=email,
+            ),
+            telphone_info=self._build_phone(customer),
+            celphone_info=self._build_mobile(customer),
+            address_info=self._build_address(customer),
+        )
+
+    def build_items(self, policy):
+        return [
+            self.map_item(item, index)
+            for index, item in enumerate(policy.itens, start=1)
+        ]
+
+    def _build_phone(self, customer):
+        for phone in customer.telefones:
+            if not phone:
+                continue
+
+            digits = "".join(filter(str.isdigit, phone))
+
+            if len(digits) < 10:
+                continue
+
+            numero = digits[2:]
+
+            if not numero.startswith("9"):
+                return Telephone(
+                    telphone_type_code="03",
+                    ddd=digits[:2],
+                    number=numero,
+                )
+
+        return None
+
+    def _build_mobile(self, customer):
+        for phone in customer.telefones:
+            if not phone:
+                continue
+
+            digits = "".join(filter(str.isdigit, phone))
+
+            if len(digits) < 10:
+                continue
+
+            numero = digits[2:]
+
+            if numero.startswith("9"):
+                return Mobile(
+                    telphone_type_code="02",
+                    ddd=digits[:2],
+                    number=numero,
+                    allow_sms=True,
+                )
+
+        return None
+
+    def _build_address(self, customer):
+        address = customer.endereco
+
+        return Address(
+            type_code="02",
+            cep=address.cep,
+            name=address.logradouro,
+            number=address.numero,
+            complement=address.complemento,
+            district=address.bairro,
+            city=address.cidade,
+            acronym_federal_unit=address.uf,
+        )
+
+    def map_item(self, item, item_number) -> InternalItem:
+        internal_item = InternalItem(
+            item_number=item_number,
+            item_type=item.tipo_item,
+        )
+
+        self.coverage_mapper.apply_all(internal_item, item.coberturas)
+
+        if item.tipo_item == "vida":
+            self._map_life(internal_item, item)
+        else:
+            self._map_vehicle(internal_item, item)
+
+        return internal_item
+
+    def _map_life(self, internal_item, item):
+        risco = item.dados_risco
+
+        internal_item.name = risco.nome
+        internal_item.cpf = risco.cpf
+        internal_item.rg = risco.rg
+        internal_item.birth_date = risco.data_nascimento
+
+    def _map_vehicle(self, internal_item, item):
+        risco = item.dados_risco
+
+        internal_item.license_plate = getattr(risco, "placa", None)
+        internal_item.chassi_number = getattr(risco, "chassi", None)
+        internal_item.fipe_code = getattr(risco, "codigo_fipe", None)
+        internal_item.body_description = self._build_body_description(item)
+
+        if item.tipo_item == "reboque":
+            internal_item.brand = getattr(risco, "marca", None)
+            internal_item.model = getattr(risco, "modelo", None)
+
+    def _build_body_description(self, item):
+        parts = []
+
+        for comp in (item.complementos or []):
+            amount = comp.importancia_segurada or 0
+            parts.append(
+                f"{comp.descricao} "
+                f"(R$ {self._format_currency(amount)})"
+            )
+
+        return " | ".join(parts)
+
+    def _format_currency(self, value):
+        return (
+            f"{value:,.2f}"
+            .replace(",", "_")
+            .replace(".", ",")
+            .replace("_", ".")
+        )

transdesk/importer/transformers/internal/rcf_parser.py

@@ -0,0 +1,47 @@
+import re
+
+
+class RCFParser:
+
+    def parse(self, produto):
+        produto = (produto or "").upper()
+
+        dma_dc = self.extract_dma_dc(produto)
+        dmo = self.extract_dmo(produto)
+
+        return {
+            "property_damage_value": dma_dc,
+            "bodily_injury_value": dma_dc,
+            "moral_damage_value": dmo,
+        }
+
+    def extract_dma_dc(self, text):
+        match = re.search(r"DMA E DC\s+([\d,]+)\s*(MILHÃO|MIL)?", text)
+
+        if not match:
+            return 0
+
+        amount = float(match.group(1).replace(",", "."))
+
+        unit = match.group(2)
+
+        if unit == "MIL":
+            return int(amount * 1000)
+
+        if unit == "MILHÃO":
+            return int(amount * 1_000_000)
+
+        return int(amount)
+
+    def extract_dmo(self, text):
+        match = re.search(r"DMO\s+([\d,]+)\s*(MIL)?", text)
+
+        if not match:
+            return 0
+
+        amount = float(match.group(1).replace(",", "."))
+
+        if match.group(2) == "MIL":
+            return int(amount * 1000)
+
+        return int(amount)