ANC
1. Funções
Dicionário
carregar()
Metodo para carregar o arquivo de configuração.
Parametro:
caminho: Diretório onde fica o arquivo [nome_do_arquivo].ini
secao: Nome da secao que deseja fazer a leitura
item: Nome do item na seção
def carregar(self, caminho, secao, item):
config_objeto = ConfigParser()
config_objeto.read(f"{caminho}")
resultado = literal_eval(config_objeto.get(secao, item))
return resultado
checar()
Método para incluir as variaveis que não foram enviadas pela ANC.
Parametros:
dct: É o dicionário enviado pelo IIB como entrada
cst: É o dicionário de constantes
def checar(self, dct, cst):
for var in cst.keys():
if var not in dct.keys():
dct[var] = cst[var]
return dct
traduzir()
Método para traduzir os dados enviados pela ANC com nomes em português,
para o nome equivalente abreviado.
Parametros:
msg: É o dicionario enviado pelo IIB como entrada.
dct: Dicionario com o De-Para que desejamos transformar o dicionario de
entrada.
def traduzir(self, msg, dct):
dict_novo = {}
if (type(msg) is str):
msg_nova = literal_eval(msg)
for k, v in msg_nova.items():
dict_novo[dct[k]] = v
else:
for k, v in msg.items():
dict_novo[dct[k]] = v
return dict_novo
reescLista()
Método para reescrever as variaveis do tipo lista no book de entrada.
Parametros:
dct: É o dicionário enviado pelo IIB como entrada.
def reescLista(self, dct):
listas = ['listaEmpregadorCliente', 'listaEmpregadorComprometido', 'listaSublimiteRenovacao', \
'listaEmpregadorConsignacaoFolha', 'listaEmpregadorRegimeEspecial', 'listaConvenio']
chaves = ['codigoEmpregadorCliente', 'codigoNatureza', 'indicadorRegraRendimentoLiquidacao', 'valorRendimentoLiquido', \
'indicadorOcupacaoPrincipalSecundario', 'codigoOcupacaoEmpregadorCliente', 'dataInicioSecundario', \
'valorRendimento', 'dataRendimento', 'codigoEmpregadorComprometido', 'codigoSublimiteRenovacao', \
'codigoEmpregadorConsignacaoFolha', 'codigoEmpregadorRegimeEspecial', 'numeroClienteConvenio', \
'indiceAjusteConvenio', 'indiceMultiplicadorConvenio', 'quantidadeMaximoMesFinanciamento', \
'valorMaximoConvenio', 'valorMenorTaxaJuro', 'codigoSublimiteCredito', 'indiceReducaoPrestacao']
ch_exec = ['dataInicioSecundario', 'dataRendimento']
# Criando as listas vazias no dicionario
for ch in chaves:
dct[ch] = []
# Reescrevendo as listas no dicionario em novas listas
for lista in listas:
for dic in dct[lista]:
for ch in chaves:
if ch in dic:
if ch in ch_exec:
if ch == 'dataRendimento':
if dic[ch] != '':
nVal = dic[ch][6:10] + "-" + dic[ch][3:5] + "-" + dic[ch][0:2]
dct[ch].append(str(nVal))
else:
dct[ch].append('0001-01-01')
else:
if dic[ch] != '':
nVal = int(dic[ch])
dct[ch].append(nVal)
else:
dct[ch].append(0)
else:
dct[ch].append(dic[ch])
dct.pop(lista, None)
# #Garante que caso não venha um um campo da lista o vlaor '0' seja inserido
# for ch in chaves:
# if len(dct[ch]) == 0:
# dct[ch].append(0)
return dct
Saída
GeraSaida()
# 1. Identificação do Cliente
'cd_cli':
self.dicio['cd_cli'],
'nr_cpf_cnpj':
self.dicio['nr_cpf_cnpj']
# 2. Rotativo
2.1. Sublimites
'vl_slim_20_apvd': int(self.dicio['vl_slim_20_apvd']),
'vl_slim_20_clcd': int(self.dicio['vl_slim_20_clcd']),
'vl_slim_178_apvd': int(self.dicio['vl_slim_178_apvd']),
'vl_slim_178_clcd': int(self.dicio['vl_slim_178_clcd']),
'vl_slim_15_apvd': int(self.dicio['vl_slim_15_apvd']),
'vl_slim_15_clcd': int(self.dicio['vl_slim_15_clcd']),
'vl_slim_53_apvd': int(self.dicio['vl_slim_53_apvd']),
'vl_slim_53_clcd': int(self.dicio['vl_slim_53_clcd'])
2.2. Grupos
'vl_grupo_62_apvd': int(self.dicio['vl_grupo_62_apvd']),
'vl_grupo_62_clcd': int(self.dicio['vl_grupo_62_clcd']),
'vl_grupo_63_apvd': int(self.dicio['vl_grupo_63_apvd']),
'vl_grupo_63_clcd': int(self.dicio['vl_grupo_63_clcd'])
2.3. Bloco
'vl_bloco_11_apvd':
int(self.dicio['vl_bloco_11_apvd']),
'vl_bloco_11_clcd':
int(self.dicio['vl_bloco_11_clcd'])
# 3. Parcelado
3.1. Sublimilites
vl_slim_21_apvd': int(self.dicio['vl_slim_21_apvd']),
'vl_slim_21_clcd': int(self.dicio['vl_slim_21_clcd']),
'vl_slim_83_apvd': int(self.dicio['vl_slim_83_apvd']),
'vl_slim_83_clcd': int(self.dicio['vl_slim_83_clcd']),
'vl_slim_111_apvd': int(self.dicio['vl_slim_111_apvd']),
'vl_slim_111_clcd': int(self.dicio['vl_slim_111_clcd']),
'vl_slim_115_apvd': int(self.dicio['vl_slim_115_apvd']),
'vl_slim_115_clcd': int(self.dicio['vl_slim_115_clcd']),
'vl_slim_116_apvd': int(self.dicio['vl_slim_116_apvd']),
'vl_slim_116_clcd': int(self.dicio['vl_slim_116_clcd']),
'vl_slim_117_apvd': int(self.dicio['vl_slim_117_apvd']),
'vl_slim_117_clcd': int(self.dicio['vl_slim_117_clcd']),
'vl_slim_119_apvd': int(self.dicio['vl_slim_119_apvd']),
'vl_slim_119_clcd': int(self.dicio['vl_slim_119_clcd']),
'vl_slim_129_apvd': int(self.dicio['vl_slim_129_apvd']),
'vl_slim_129_clcd': int(self.dicio['vl_slim_129_clcd']),
'vl_slim_131_apvd': int(self.dicio['vl_slim_131_apvd']),
'vl_slim_131_clcd': int(self.dicio['vl_slim_131_clcd']),
'vl_slim_137_apvd': int(self.dicio['vl_slim_137_apvd']),
'vl_slim_137_clcd': int(self.dicio['vl_slim_137_clcd']),
'vl_slim_140_apvd': int(self.dicio['vl_slim_140_apvd']),
'vl_slim_140_clcd': int(self.dicio['vl_slim_140_clcd']),
'vl_slim_142_apvd': int(self.dicio['vl_slim_142_apvd']),
'vl_slim_142_clcd': int(self.dicio['vl_slim_142_clcd']),
'vl_slim_155_apvd': int(self.dicio['vl_slim_155_apvd']),
'vl_slim_155_clcd': int(self.dicio['vl_slim_155_clcd']),
'vl_slim_156_apvd': int(self.dicio['vl_slim_156_apvd']),
'vl_slim_156_clcd': int(self.dicio['vl_slim_156_clcd']),
'vl_slim_157_apvd': int(self.dicio['vl_slim_157_apvd']),
'vl_slim_157_clcd': int(self.dicio['vl_slim_157_clcd']),
'vl_slim_159_apvd': int(self.dicio['vl_slim_159_apvd']),
'vl_slim_159_clcd': int(self.dicio['vl_slim_159_clcd']),
'vl_slim_160_apvd': int(self.dicio['vl_slim_160_apvd']),
'vl_slim_160_clcd': int(self.dicio['vl_slim_160_clcd']),
'vl_slim_161_apvd': int(self.dicio['vl_slim_161_apvd']),
'vl_slim_161_clcd': int(self.dicio['vl_slim_161_clcd']),
'vl_slim_162_apvd': int(self.dicio['vl_slim_162_apvd']),
'vl_slim_162_clcd': int(self.dicio['vl_slim_162_clcd']),
'vl_slim_163_apvd': int(self.dicio['vl_slim_163_apvd']),
'vl_slim_163_clcd': int(self.dicio['vl_slim_163_clcd']),
'vl_slim_171_apvd': int(self.dicio['vl_slim_171_apvd']),
'vl_slim_171_clcd': int(self.dicio['vl_slim_171_clcd']),
'vl_slim_173_apvd': int(self.dicio['vl_slim_173_apvd']),
'vl_slim_173_clcd': int(self.dicio['vl_slim_173_clcd']),
'vl_slim_179_apvd': int(self.dicio['vl_slim_179_apvd']),
'vl_slim_179_clcd': int(self.dicio['vl_slim_179_clcd']),
'vl_slim_180_apvd': int(self.dicio['vl_slim_180_apvd']),
'vl_slim_180_clcd': int(self.dicio['vl_slim_180_clcd']),
'vl_slim_181_apvd': int(self.dicio['vl_slim_181_apvd']),
'vl_slim_181_clcd': int(self.dicio['vl_slim_181_clcd']),
'vl_slim_228_apvd': int(self.dicio['vl_slim_228_apvd']),
'vl_slim_228_clcd': int(self.dicio['vl_slim_228_clcd']),
'vl_pstc_cdc_apvd': int(self.dicio['vl_pstc_cdc_apvd']),
'vl_pstc_cdc_clcd': int(self.dicio['vl_pstc_cdc_clcd']),
'vl_pstc_fin_apvd': int(self.dicio['vl_pstc_fin_apvd']),
'vl_pstc_fin_clcd': int(self.dicio['vl_pstc_fin_clcd']),
'vl_pstc_rao_apvd': int(self.dicio['vl_pstc_rao_apvd']),
'vl_pstc_rao_clcd': int(self.dicio['vl_pstc_rao_clcd']),
'vl_pstc_vclo_apvd': int(self.dicio['vl_pstc_vclo_apvd']),
'vl_pstc_vclo_clcd': int(self.dicio['vl_pstc_vclo_clcd']),
'vl_pstc_cdc_prtt': int(self.dicio['vl_pstc_cdc_prtt']),
'vl_ren_slr_bnf': int(self.dicio['vl_ren_slr_bnf'])
3.2. Grupo
'vl_grupo_45_apvd': int(self.dicio['vl_grupo_45_apvd']),
'vl_grupo_45_clcd': int(self.dicio['vl_grupo_45_clcd']),
'vl_grupo_46_apvd': int(self.dicio['vl_grupo_46_apvd']),
'vl_grupo_46_clcd': int(self.dicio['vl_grupo_46_clcd']),
'vl_grupo_55_apvd': int(self.dicio['vl_grupo_55_apvd']),
'vl_grupo_55_clcd': int(self.dicio['vl_grupo_55_clcd']),
'vl_grupo_60_apvd': int(self.dicio['vl_grupo_60_apvd']),
'vl_grupo_60_clcd': int(self.dicio['vl_grupo_60_clcd']),
'vl_grupo_64_apvd': int(self.dicio['vl_grupo_64_apvd']),
'vl_grupo_64_clcd': int(self.dicio['vl_grupo_64_clcd']),
'vl_grupo_65_apvd': int(self.dicio['vl_grupo_65_apvd']),
'vl_grupo_65_clcd': int(self.dicio['vl_grupo_65_clcd'])
3.3. Bloco
'vl_bloco_14_apvd': int(self.dicio['vl_bloco_14_apvd']),
'vl_bloco_14_clcd': int(self.dicio['vl_bloco_14_clcd']),
# 4. Consignado
'vl_slim_130_apvd': int(self.dicio['vl_slim_130_apvd']),
vl_slim_130_clcd': int(self.dicio['vl_slim_130_clcd']),
'in_grava_cvn': self.dicio['in_grava_cvn'],
'vl_pstc_crd_slr': int(self.dicio['vl_pstc_083']),
'vl_ren_utzd_pstc_ecf': round(self.dicio['vl_ren_utzd_pstc_ecf'], 2),
'vl_renda_funci': round(self.dicio['vl_renda_funci'], 2),
'vl_renda_liq_ttl': round(self.dicio['vl_renda_liq_ttl'], 2),
'vl_renda_pres': round(self.dicio['vl_renda_pres'], 2),
'vl_pstc_ecf_clcd': int(self.dicio['vl_pstc_ecf_clcd']),
'vl_pstc_ecf_apvd': int(self.dicio['vl_pstc_ecf_apvd']),
'ic_ajst_cvn_137': int(self.dicio['ic_ajst_cvn_137']),
'vl_pstc_137': int(self.dicio['vl_pstc_137']),
'ic_ajst_cvn_171': int(self.dicio['ic_ajst_cvn_171']),
'vl_max_cvn_083': int(self.dicio['vl_max_cvn_083']),
'vl_max_cvn_137': int(self.dicio['vl_max_cvn_137']),
'vl_max_cvn_171': int(self.dicio['vl_max_cvn_171']),
'vl_pstc_fun_bb_clcd': int(self.dicio['vl_pstc_fun_bb_clcd']),
'vl_pstc_ecf_demais': int(self.dicio['vl_pstc_ecf_demais']),
'vl_pstc_fun_bb_apvd': int(self.dicio['vl_pstc_fun_bb_apvd']),
'ic_mtp_clc_slim_137': round(self.dicio['vl_mtp_clc_slim_137'], 6)
2. Rotativo
ProcRotativo
ProcessaRotativo()
Cálculos
calc_apvd_far
Método para calcular valor
aprovado e calculado com FAR.
# Instância
te = TratarErro(self.caminho)
# Valor Calculado e Aprovado com
FAR - Cheque Especial
try:
self.dicio["ws_vl_clcd_far_015"] =
self.dicio["vl_slim_15_clcd"] *
self.dicio["vl_ftr_ajst_slim_015"]
self.dicio["ws_vl_apvd_far_015"] =
self.dicio["vl_slim_15_apvd"] *
self.dicio["vl_ftr_ajst_slim_015"]
except:
te.getError('014')
# Cartão de Crédito
try:
self.dicio["ws_vl_clcd_far_020"] = self.dicio["vl_slim_20_clcd"] *
self.dicio["vl_ftr_ajst_slim_020"]
self.dicio["ws_vl_apvd_far_020"] = self.dicio["vl_slim_20_apvd"] *
self.dicio["vl_ftr_ajst_slim_020"]
except:
te.getError('015')
calc_perc_rot
# Calcula XYZ% do calculado 15/20 para uso do publico GT-FRAUDE
# o registro da planilha de Teste tem as variáveis cd_tip_cpvt_ren == 'C' e
in_rlc_cli == 'C'.
# Como as condições nao permitem a mudança do valor da variavel
waux_pc_clcd_rel, ela continua com o valor 0
# e zera o calculo do sublimite final.
# Instâncias
te = TratarErro(self.caminho)
# Variáveis
waux_pc_clcd_rel = 0
# Definindo o percentual a ser
aplicado de acordo com o tipo de
comprovante de renda e tipo de
relacionamento do cliente.
if self.dicio["cd_tip_cpvt_ren"] == 'F':
if self.dicio["in_rlc_cli"] == 'P':
waux_pc_clcd_rel = self.dicio["vl_pc_cpv_fmal_p"]
if self.dicio["in_rlc_cli"] == 'C':
waux_pc_clcd_rel = self.dicio["vl_pc_cpv_fmal_c"]
elif self.dicio["cd_tip_cpvt_ren"] == 'C':
if self.dicio["in_rlc_cli"] in ('I', '', ' ', ' '):
waux_pc_clcd_rel = self.dicio["vl_pc_ren_cpvd_i"]
if self.dicio["in_rlc_cli"] == 'P':
if self.dicio["cd_rsco_05"] in ('A', 'B'):
waux_pc_clcd_rel = self.dicio["vl_pc_ren_cpvd_p_ab"]
if self.dicio["cd_rsco_05"] in ('C', 'D'):
waux_pc_clcd_rel = self.dicio["vl_pc_ren_cpvd_p_cd"]
# Aplicando percentual de redução
- Cheque Especial
try:
self.dicio["wgda_vl_slim_15_clcd"] =
self.dicio["vl_slim_15_clcd"] * (waux_pc_clcd_rel / 100)
except:
te.getError('009')
# Aplicando percentual de redução
- Cartão de Crédito
try:
self.dicio["wgda_vl_slim_20_clcd"] =
self.dicio["vl_slim_20_clcd"] * (waux_pc_clcd_rel / 100)
except:
te.getError('010')
calculoAgrup
Método para calcular os valores
de agrupamentos
calcularGrupos()
# Instâncias
te = TratarErro(self.caminho)
# Inicialização das Variáveis
self.dicio["vl_grupo_62_clcd"] = 0
self.dicio["vl_grupo_62_apvd"] = 0
self.dicio["vl_grupo_63_clcd"] = 0
self.dicio["vl_grupo_63_apvd"] = 0
# Cheque Especial - Calculado e
Aprovado
try:
self.dicio["vl_grupo_62_clcd"] =
self.dicio["vl_slim_15_clcd"] +
self.dicio["vl_slim_53_clcd"]
self.dicio["vl_grupo_62_apvd"] =
self.dicio["vl_slim_15_apvd"] +
self.dicio["vl_slim_53_apvd"]
except:
te.getError('012')
# Cartão de Crédito - Calculado e
Aprovado
try:
self.dicio["vl_grupo_63_clcd"] =
self.dicio["vl_slim_20_clcd"] +
self.dicio["vl_slim_178_clcd"]
self.dicio["vl_grupo_63_apvd"] =
self.dicio["vl_slim_20_apvd"] +
self.dicio["vl_slim_178_apvd"]
except:
te.getError('013')
calcularBlocos()
def calcularBlocos(self):
self.dicio["vl_bloco_11_apvd"] = 0
self.dicio["vl_bloco_11_clcd"] = 0
if self.dicio["vl_grupo_62_clcd"] >= self.dicio["vl_grupo_63_clcd"]:
self.dicio["vl_bloco_11_clcd"] = self.dicio["vl_grupo_62_clcd"]
else:
self.dicio["vl_bloco_11_clcd"] = self.dicio["vl_grupo_63_clcd"]
if self.dicio["vl_grupo_62_apvd"] >= self.dicio["vl_grupo_63_apvd"]:
self.dicio["vl_bloco_11_apvd"] = self.dicio["vl_grupo_62_apvd"]
elif self.dicio["cd_crct_1682"] == 1:
self.dicio["vl_bloco_11_apvd"] = self.dicio["vl_grupo_63_apvd"]
else:
self.dicio["vl_bloco_11_apvd"] = self.dicio["vl_grupo_63_apvd"]
calculo_sublimite
calcLimRef()
Função para cálculo do Limite Referencial para os
produtos:
- Cartão de Crédito
- Cheque Especial
Parametros:
prd: Tipo do Produto que deseja calcular:
- CHQ - Cheque Especial
- CRT - Cartão de Crédito
# Instâncias
te = TratarErro(self.caminho)
# Variáveis de Entrada
fator_desemp = self.dicio["vl_ftr_demp"]
fator_relac = self.dicio["cd_ftr_rlc"]
renda = self.dicio['vl_rend_lqdo_ttl']
if prd == "CHQ":
coeficiente = self.dicio['vl_cfct_015']
limite_ref = self.dicio['vl_lim_ref_015']
else:
coeficiente = self.dicio['vl_cfct_020']
limite_ref = self.dicio['vl_lim_ref_020']
# Cálculo do limite referencial
try:
result = fator_desemp * fator_relac * coeficiente * renda
except:
te.getError('005')
# Validação
if result > limite_ref:
if prd == "CHQ":
self.dicio['vl_slim_15_clcd'], self.dicio['vl_slim_15_apvd'] = limite_ref, limite_ref
else:
self.dicio['vl_slim_20_clcd'], self.dicio['vl_slim_20_apvd'] = limite_ref, limite_ref
else:
if prd == "CHQ":
self.dicio['vl_slim_15_clcd'], self.dicio['vl_slim_15_apvd'] = int(result), int(result)
else:
self.dicio['vl_slim_20_clcd'], self.dicio['vl_slim_20_apvd'] = int(result), int(result)
Módulos
ancs0126
ancs0126()
# Instâncias
te = TratarErro(self.caminho)
# Variáveis
ancs0126_vl_rtv_apvc = self.anc0126['ancs0126_vl_rtv_clcd']
rv.recuperaVips(self)
if self.anc0126['ancs0126_in_sem_cta_cartao'] == 'S':
return 1
ancs0126_rc = rl.recuperaLimRotAnt(self)
if ancs0126_rc != 0:
return 1
# A. Clientes com caracteristica XX VIP, sem sinal de alerta
1 ou 2 e cujo rotativo anterior seja >= 500 e < 800
if self.anc0126['ancs0126_in_crct_xx'] == 'S' and self.anc0126['ancs0126_in_snl_alr'] not in (1, 2) \
and self.anc0126['ancs0126_vl_rtv_ant'] >= self.anc0126['ancs0126_vl_min_crt_unit'] \
and self.anc0126['ancs0126_vl_rtv_ant'] < self.anc0126['ancs0126_vl_max_crt_unit']:
if self.anc0126['ancs0126_cd_rsco_clcd'] > self.anc0126['ancs0126_cd_rsco_ant']:
self.anc0126['ancs0126_vl_rtv_apvc'] = self.anc0126['ancs0126_vl_rtv_ant']
else:
if self.anc0126['qtd_dias_anl_ant'] > 150:
try:
self.anc0126['ancs0126_vl_rtv_apvc'] = self.anc0126['ancs0126_vl_rtv_ant'] * 1.2
except:
te.getError('022')
if self.anc0126['ancs0126_vl_rtv_apvc'] > self.anc0126['ancs0126_vl_max_crt_unit']:
self.anc0126['ancs0126_vl_rtv_apvc'] = self.anc0126['ancs0126_vl_max_crt_unit']
return 0
# B. Clientes com caracteristica ZZ VIP, sem sinal de alerta
1 ou 2 e cujo rotativo anterior seja >= 500 e < 800
if self.anc0126['ancs0126_in_crct_zz'] == 'S' and self.anc0126['ancs0126_in_snl_alr'] not in (1, 2) \
and self.anc0126['ancs0126_vl_rtv_ant'] >= self.anc0126['ancs0126_vl_min_crt_unit'] \
and self.anc0126['ancs0126_vl_rtv_ant'] < self.anc0126['ancs0126_vl_max_crt_unit']:
if self.anc0126['ancs0126_cd_rsco_clcd'] <= self.anc0126['ancs0126_cd_rsco_ant']:
self.anc0126['ancs0126_vl_rtv_apvc'] = self.anc0126['ancs0126_vl_rtv_ant']
else:
if self.anc0126['ancs0126_vl_rtv_ant'] < self.anc0126['ancs0126_vl_maior_fat_vip']:
self.anc0126['ancs0126_vl_rtv_apvc'] = self.anc0126['ancs0126_vl_rtv_ant']
else:
self.anc0126['ancs0126_vl_rtv_apvc'] = self.anc0126['ancs0126_vl_maior_fat_vip']
if self.anc0126['ancs0126_vl_rtv_apvc'] < self.anc0126['ancs0126_vl_min_crt_unit']:
self.anc0126['ancs0126_vl_rtv_apvc'] = self.anc0126['ancs0126_vl_min_crt_unit']
return 0
# C. Clientes cujo rotativo estabelecido na analise anterior seja
inferior a 500,00 ou superior a 800,00: sera estabelecido o maior
entre: piso de 500,00, o calculado e o estabelecido anterior.
if self.anc0126['ancs0126_vl_rtv_ant'] < self.anc0126['ancs0126_vl_min_crt_unit'] or \
self.anc0126['ancs0126_vl_rtv_ant'] > self.anc0126['ancs0126_vl_max_crt_unit']:
if self.anc0126['ancs0126_vl_rtv_ant'] < self.anc0126['ancs0126_vl_rtv_clcd']:
self.anc0126['ancs0126_vl_rtv_apvc'] = self.anc0126['ancs0126_vl_rtv_clcd']
else:
self.anc0126['ancs0126_vl_rtv_apvc'] = self.anc0126['ancs0126_vl_rtv_ant']
if self.anc0126['ancs0126_vl_rtv_apvc'] <
self.anc0126['ancs0126_vl_min_crt_unit']:
self.anc0126['ancs0126_vl_rtv_apvc'] =
self.anc0126['ancs0126_vl_min_crt_unit']
return 0
# D. Clientes com sinal de alerta 1: será estabelecido o
valor do rotatvio anterior.
if self.anc0126['ancs0126_in_snl_alr'] == 1:
self.anc0126['ancs0126_vl_rtv_apvc'] =
self.anc0126['ancs0126_vl_rtv_ant']
if self.anc0126['ancs0126_vl_rtv_apvc'] <
self.anc0126['ancs0126_vl_min_crt_unit']:
self.anc0126['ancs0126_vl_rtv_apvc'] =
self.anc0126['ancs0126_vl_min_crt_unit']
return 0
# E. Clientes com sinal de alerta 2: será estabelecido o menor entre: I. O calculado
e o Piso de 500,00 (o que for maior) II. O limite rotativo anteior LIMITE ROTATIVO
ANTERIOR.
if self.anc0126['ancs0126_in_snl_alr'] == 2:
if self.anc0126['ancs0126_vl_rtv_clcd'] > self.anc0126['ancs0126_vl_min_crt_unit']:
self.anc0126['ancs0126_vl_rtv_apvc'] = self.anc0126['ancs0126_vl_rtv_clcd']
else:
self.anc0126['ancs0126_vl_rtv_apvc'] = self.anc0126['ancs0126_vl_min_crt_unit']
if self.anc0126['ancs0126_vl_rtv_apvc'] > self.anc0126['ancs0126_vl_rtv_ant']:
self.anc0126['ancs0126_vl_rtv_apvc'] = self.anc0126['ancs0126_vl_rtv_ant']
return 0
recuperaDadosVip()
Método responsável pela recuperação de
dados dos clientes pela subrotina VIPS0244
# Dicionario de Parametro para a
Função VIPS0244
self.anc0126['ancs0126_vl_maior_fat_vip'] = 0
self.anc0126['ancs0126_qt_utlz_vip'] = 0
self.anc0126['ancs0126_in_sem_cta_cartao'] = 'N'
self.anc0126['ancs0126_in_crct_xx'] = 'N'
self.anc0126['ancs0126_in_crct_zz'] = 'N'
# Realiza a consulta na subrotina
VIPS0244
vip.consultar(self)
if self.anc0126['ancs0126_in_sem_cta_cartao'] == 'N':
for i in range(0, 6):
if self.vips0244['vips0244_vl_soma_fat'][i] > self.anc0126['ancs0126_vl_maior_fat_vip']:
self.anc0126['ancs0126_vl_maior_fat_vip'] = self.vips0244['vips0244_vl_soma_fat'][i]
if self.vips0244['vips0244_vl_soma_fat'][i] > 0:
self.anc0126['ancs0126_qt_utlz_vip'] += 1
self.anc0126['ancs0126_vl_utlz_media_vip'] = self.vips0244['vips0244_vl_soma_fat'][i]
if self.anc0126['ancs0126_qt_utlz_vip'] > 0:
self.anc0126['ancs0126_vl_utlz_media_vip'] = self.anc0126['ancs0126_vl_utlz_media_vip'] /
self.anc0126['ancs0126_qt_utlz_vip']
else:
self.anc0126['ancs0126_vl_utlz_media_vip'] = 0
# Compõe Características XX e ZZ
if self.anc0126['ancs0126_vl_lim_ctr_vip'] == 0:
self.anc0126['ancs0126_pc_utlz_vip'] = 0
else:
self.anc0126['ancs0126_pc_utlz_vip'] = (self.anc0126['ancs0126_vl_utlz_media_vip'] * 100) / self.vips0244['vips0244_lim_ctrl']
if self.anc0126['ancs0126_pc_utlz_vip'] >= 80.00 and self.vips0244['vips0244_rfnt_ult_6m'] == 'N' and self.vips0244['vips0244_atr_ult_6m'] == 'N':
self.anc0126['ancs0126_in_crct_xx'] = 'S'
if self.anc0126['ancs0126_pc_utlz_vip'] < 80.00 and self.vips0244['vips0244_rfnt_ult_6m'] == 'S' and self.vips0244['vips0244_atr_ult_6m'] == 'S':
self.anc0126['ancs0126_in_crct_zz'] = 'S'
return 1
recuperaLimRot()
Método para recuperar a última
análise do cliente
# Instâncias
te = TratarErro(self.caminho)
self.DB2_USER = os.environ.get("DB2_USER")
self.DB2_PASSWORD =
os.environ.get("DB2_PASSWORD")
connID = Db2(self.DB2_USER, self.DB2_PASSWORD)
# Recuperamos a data da última
análise
try:
query1 = "SELECT TS_ACLT_SLC, CD_MTDL_ANL_CRD FROM DB2ANC.LMCR_CLI \
WHERE CD_CLI = {0} FETCH FIRST 1 ROW ONLY".format(self.anc0126['ancs0126_cd_cli'])
res1 = connID.query(query1, chunksize=None)
except:
te.getError('023')
if len(res1) == 0:
self.anc0126['ancs0126_qtd_dias_anl_ant'] = 0
self.anc0126['ancs0126_vl_rtv_ant'] = 0
self.anc0126['ancs0126_cd_rsco_ant'] = 0
else:
gda_ts_slct = str(res1['TS_ACLT_SLC'][0])
gda_cd_mtdl_anl_crd = res1['CD_MTDL_ANL_CRD'][0]
# Consulta Risco FEI da análise
anterior
try:
query2 = "SELECT CD_RSCO_PRVR_CLI FROM DB2ANC.SLCT_LMCR \
WHERE CD_CLI = {0} AND TS_ACLT_SLC = '{1}' FETCH FIRST 1 ROW ONLY".format(self.anc0126['ancs0126_cd_cli'], gda_ts_slct)
res2 = connID.query(query2, chunksize=None)
except:
te.getError('024')
if len(res2) == 0:
self.anc0126['ancs0126_qtd_dias_anl_ant'] = 0
self.anc0126['ancs0126_vl_rtv_ant'] = 0
self.anc0126['ancs0126_cd_rsco_ant'] = 0
else:
self.anc0126['ancs0126_cd_rsco_ant'] = res2['CD_RSCO_PRVR_CLI'][0]
try:
if gda_cd_mtdl_anl_crd > 50:
cd_slim_crd = 20
else:
cd_slim_crd = 143
query3 = "SELECT VL_SLIM_APVD FROM DB2ANC.SLIM_CRD_CLI \
WHERE CD_CLI = {0} AND CD_SLIM_CRD = {1} AND TS_ACLT_SLC = '{2}' \
FETCH FIRST 1 ROW ONLY".format(self.anc0126['ancs0126_cd_cli'], cd_slim_crd, gda_ts_slct)
res3 = connID.query(query3, chunksize=None)
except:
te.getError('025')
if len(res3) == 0:
self.anc0126['ancs0126_vl_rtv_ant'] = 0
else:
self.anc0126['ancs0126_vl_rtv_ant'] = res3['VL_SLIM_APVD'][0]
return 0
vips0244
vips0244()
# Procedimentos Iniciais
self.vips0244 = {}
self.vips0244['vips0244_gda_cur_date'] = datetime.now()
self.vips0244['vips0244_gda_mescur'] =
self.vips0244['vips0244_gda_cur_date'].month
self.vips0244['vips0244_gda_mescur_aux'] =
self.vips0244['vips0244_gda_cur_date'].month
self.vips0244['vips0244_gda_anocur_aux'] =
self.vips0244['vips0244_gda_cur_date'].year
self.vips0244['vips0244_vl_soma_fat'] = [0, 0, 0, 0, 0, 0]
# Pegar últimos 6 meses e joga em
uma lista
self.vips0244['vips0244_mm_inf'] = []
for i in range(1,7):
if self.vips0244['vips0244_gda_mescur_aux'] == 0:
self.vips0244['vips0244_gda_mescur_aux'] = 12
self.vips0244['vips0244_gda_anocur_aux'] = self.vips0244['vips0244_gda_anocur_aux'] - 1
self.vips0244['vips0244_mm_inf'].append(self.vips0244['vips0244_gda_mescur_aux'])
self.vips0244['vips0244_gda_mescur_aux'] = self.vips0244['vips0244_gda_mescur_aux'] - 1
# Verifica se o cliente possui conta
cartão
vcc.verificaContaCartao(self)
# Verifica se o cliente possui atraso
no pagamento da Conta Cartão
f self.anc0126['ancs0126_in_sem_cta_cartao'] == 'N':
# Verifica se o cliente possui atraso no pagamento da Conta Cartão
va.verificaAtraso(self)
return 1
verificaAtraso()
Método responsável por recuperar
os dados do contrato de conta
cartão e verificar se o cliente teve
atraso e refinanciamento nos
últimos 6 meses.
# Instâncias
te = TratarErro(self.caminho)
# Declaração de Variáveis
self.DB2_USER = os.environ.get("DB2_USER")
self.DB2_PASSWORD = os.environ.get("DB2_PASSWORD")
connID = Db2(self.DB2_USER, self.DB2_PASSWORD)
self.vips0244['vips0244_gda_prim'] = 'S'
self.vips0244['vips0244_rfnt_ult_6m'] = 'N'
self.vips0244['vips0244_atr_ult_6m'] = 'N'
self.gda_nr_seql_fat_ct_crt = 0
self.gda_vl_refinanc = 0
# Recupera dados da conta cartão
do cliente
try:
query = "SELECT DISTINCT A.NR_CT_CRT, A.DT_ABTR_CT, A.DT_FIM_CT, A.CD_TIP_RST_CRT_CRD, \
B.NR_SEQL_FAT_CT_CRT, C.VL_SDO_FAT_CT_CRT, C.CD_TIP_SDO, E.DT_PRVT_VNCT_FAT \
FROM DB2VIP.CT_CRT A, DB2VIP.FAT_CT_CRT B, DB2VIP.SDO_FAT_CT_CRT C, \
DB2VIP.TIP_SDO D, DB2VIP.CLDR_FATM E WHERE A.CD_CLI = {0} \
AND A.NR_CT_CRT = B.NR_CTR_OPR_CT_CRT AND B.NR_SEQL_FAT_CT_CRT = C.NR_SEQL_FAT_CT_CRT \
AND C.CD_TIP_SDO IN (03 , 05 , 101 , 107) AND D.CD_TIP_SDO IN (03 , 05 , 101 , 107) \
AND E.CD_CLDR_FATM = B.CD_CLDR_FATM AND E.DT_PRVT_VNCT_FAT >= (CURRENT DATE - 6 MONTH) \
AND E.DT_PRVT_VNCT_FAT <= (CURRENT DATE - 6 DAYS) AND E.CD_ORGZ_CT_CRT = 100 \
ORDER BY B.NR_SEQL_FAT_CT_CRT DESC, C.CD_TIP_SDO".format(self.anc0126['ancs0126_cd_cli'])
result = connID.query(query, chunksize=None)
except:
te.getError('028')
if len(result) == 0:
if self.vips0244['vips0244_gda_prim'] != 'N':
# Cliente sem faturas no período
self.anc0126['ancs0126_in_sem_cta_cartao'] = 'S'
return 1
else:
self.vips0244['vips0244_gda_prim'] = 'N'
for i in range(0, len(result)):
linha = result.to_dict(orient='records')[i]
# Recupera o tempo de atraso do
Pagamento da Conta Cartão
try:
query = "SELECT COUNT (*) AS GDA_COUNT FROM DB2VIP.ATR_PGTO_CT_CRT WHERE
NR_CT_CRT = {0} AND ( \
(MM_REF_ATR = MONTH(CURRENT DATE - 5 MONTH) AND AA_REF_ATR =
YEAR(CURRENT DATE - 5 MONTH)) OR \
(MM_REF_ATR = MONTH(CURRENT DATE - 4 MONTH) AND AA_REF_ATR =
YEAR(CURRENT DATE - 4 MONTH)) OR \
(MM_REF_ATR = MONTH(CURRENT DATE - 3 MONTH) AND AA_REF_ATR =
YEAR(CURRENT DATE - 3 MONTH)) OR \
(MM_REF_ATR = MONTH(CURRENT DATE - 2 MONTH) AND AA_REF_ATR =
YEAR(CURRENT DATE - 2 MONTH)) OR \
(MM_REF_ATR = MONTH(CURRENT DATE - 1 MONTH) AND AA_REF_ATR =
YEAR(CURRENT DATE - 1 MONTH)) OR \
(MM_REF_ATR = MONTH(CURRENT DATE) AND AA_REF_ATR = YEAR(CURRENT
DATE)))".format(linha['NR_CT_CRT'])
gda_atraso = connID.query(query, chunksize=None)['GDA_COUNT'][0]
# Marca se o cliente tem atraso nos
últimos 6 meses
if gda_atraso > 0:
self.vips0244['vips0244_atr_ult_6m'] = 'S'
except:
te.getError('029')
# Verifica o valor da fatura dos
últimos 6 meses
f linha['CD_TIP_SDO'] == 107:
for i in range(0, 6):
if self.vips0244['vips0244_mm_inf'][i] == linha['DT_PRVT_VNCT_FAT'].month:
self.vips0244['vips0244_vl_soma_fat'].append(linha['VL_SDO_FAT_CT_CRT'])
break
# Marca se o cliente tem
refinanciamento nos últimos 6
meses
if self.gda_nr_seql_fat_ct_crt != linha['NR_SEQL_FAT_CT_CRT']:
if self.gda_nr_seql_fat_ct_crt != 0:
if self.gda_vl_refinanc > 0:
self.vips0244['vips0244_rfnt_ult_6m'] = 'S'
self.gda_vl_refinanc = 0
self.gda_nr_seql_fat_ct_crt = linha['NR_SEQL_FAT_CT_CRT']
if linha['CD_TIP_SDO'] in (3, 5, 101):
self.gda_vl_refinanc = linha['VL_SDO_FAT_CT_CRT']
verificaContaCartão()
Método responsável por consultar se o cliente possui conta cartão
e o respectivo valor de limite contratado.
# Instâncias
te = TratarErro(self.caminho)
# Cria a conexão com o DB2
self.DB2_USER = os.environ.get("DB2_USER")
self.DB2_PASSWORD = os.environ.get("DB2_PASSWORD")
connID = Db2(self.DB2_USER, self.DB2_PASSWORD)
self.anc0126['ancs0126_in_sem_cta_cartao'] = 'S'
self.anc0126['ancs0126_vl_lim_ctr_vip'] = 0
# Verifica se o cliente possui conta
cartão
try:
query = "SELECT COUNT (*) as GDA_COUNT FROM DB2VIP.CT_CRT \
WHERE CD_CLI = {0} AND ((DT_FIM_CT = '01/01/0001') OR \
(DT_FIM_CT > CURRENT DATE - 6
MONTH))".format(self.anc0126['ancs0126_cd_cli'])
result = connID.query(query, chunksize=None)['GDA_COUNT'][0]
if result == 0:
self.anc0126['ancs0126_in_sem_cta_cartao'] = 'S'
else:
self.anc0126['ancs0126_in_sem_cta_cartao'] = 'N'
except:
te.getError('026')
# Recupera o Limite Contratado do
cliente com conta cartão
if self.anc0126['ancs0126_in_sem_cta_cartao'] == 'N':
try:
query = "SELECT VL_LIM_CLI_PF, VL_LIM_RTV_CLI_PF FROM
DB2VIP.LIM_CLI_PF \
WHERE CD_CLI_PF = {0}".format(self.anc0126['ancs0126_cd_cli'])
self.anc0126['ancs0126_vl_lim_ctr_vip'] = connID.query(query,
chunksize=None)['VL_LIM_RTV_CLI_PF'][0]
except:
te.getError('027')
Regras
aplicaSnlAlerta()
Função para Aplicação de Sinal de Alerta para os produtos:
- Cartão de Crédito
- Cheque Especial
Parametros:
prd: Tipo do Produto que deseja calcular:
- CHQ - Cheque Especial
- CRT - Cartão de Crédito
# Aplicação de Sinal de Alerta para
Cheque Especial
Regra 1 - Sinal 0
if self.dicio['cd_snl_avs_chq_espl'] == 0:
if (self.dicio['ind_pbco_min'] == 'N') and (self.dicio['ind_pbco_fraude'] == 'N'):
if self.dicio['in_lim_ant'] == "N":
self.dicio['vl_slim_15_ant'] = 0
if self.dicio['vl_slim_15_ant'] > self.dicio['vl_slim_15_clcd']:
self.dicio['vl_slim_15_apvd'] = self.dicio['vl_slim_15_ant']
else:
self.dicio['vl_slim_15_apvd'] = self.dicio['vl_slim_15_clcd']
# Regra 2 - Sinal 1
if self.dicio['cd_snl_avs_chq_espl'] == 1:
if self.dicio['in_lim_ant'] == "N":
self.dicio['vl_slim_15_apvd'] =
self.dicio['vl_slim_15_clcd']
else:
self.dicio['vl_slim_15_apvd'] =
self.dicio['vl_slim_15_ant']
# Regra 3 - Sinal 2, 5 e 6
if self.dicio['cd_snl_avs_chq_espl'] in (2,5,6):
if self.dicio['in_lim_ant'] == "N":
self.dicio['vl_slim_15_apvd'] = self.dicio['vl_slim_15_clcd']
else:
if self.dicio['vl_slim_15_ant'] < self.dicio['vl_slim_15_clcd']:
self.dicio['vl_slim_15_apvd'] = self.dicio['vl_slim_15_ant']
else:
self.dicio['vl_slim_15_apvd'] = self.dicio['vl_slim_15_clcd']
# Regra 4 - Sinal 4
if self.dicio['cd_snl_avs_chq_espl'] == 4:
self.dicio['vl_slim_15_apvd'] = self.dicio['vl_slim_15_clcd'] *
self.dicio['vl_pc_red_lim_clcd']
# Aplicação de Sinal de Alerta para
Cartão de Crédito
Regra 1 - Sinal 0
if self.dicio['cd_snl_avs_crt_crd'] == 0:
if (self.dicio['ind_pbco_min'] == 'N') and (self.dicio['ind_pbco_fraude'] == 'N'):
if self.dicio['vl_slim_20_ant'] > self.dicio['vl_slim_20_clcd']:
self.dicio['vl_slim_20_apvd'] = self.dicio['vl_slim_20_ant']
else:
self.dicio['vl_slim_20_apvd'] = self.dicio['vl_slim_20_clcd']
# Regra 2 - Sinal 1
if self.dicio['cd_snl_avs_crt_crd'] == 1:
self.dicio['vl_slim_20_apvd'] =
self.dicio['vl_slim_20_ant']
# Regra 3 - Sinal 2, 5 e 6
if self.dicio['cd_snl_avs_crt_crd'] in (2,5,6):
if self.dicio['vl_slim_20_ant'] < self.dicio['vl_slim_20_clcd']:
self.dicio['vl_slim_20_apvd'] = self.dicio['vl_slim_20_ant']
else:
self.dicio['vl_slim_20_apvd'] = self.dicio['vl_slim_20_clcd']
# Regra 4 - Sinal 4
if self.dicio['cd_snl_avs_crt_crd'] == 4:
self.dicio['vl_slim_20_apvd'] =
self.dicio['vl_slim_20_clcd'] *
self.dicio['vl_pc_red_lim_clcd']
aplicaTeto()
Metodo para calcular o teto dos valores dos sublimites de
acordo com a renda parametrizada de 40% e 80%.
# Instancias
te = TratarErro(self.caminho)
if wgda_vlr_rndm_lqdo_total <= wgda_vl_pc40_rnd_parm_teto:
try:
wgda_teto_slim_15 = wgda_vlr_rndm_lqdo_total * 1
wgda_teto_slim_20 = wgda_vlr_rndm_lqdo_total * 1
except:
te.getError('007')
elif wgda_vlr_rndm_lqdo_total <= wgda_vl_pc80_rnd_parm_teto:
try:
wgda_teto_slim_15 = wgda_vlr_rndm_lqdo_total * 1.5
wgda_teto_slim_20 = wgda_vlr_rndm_lqdo_total * 1.5
except:
te.getError('008')
else:
wgda_teto_slim_15 = 0
wgda_teto_slim_20 = 0
return wgda_teto_slim_15, wgda_teto_slim_20
apurarTeto()
if self.dicio["cd_sgm_anl"] == 39 or self.dicio["in_bco_pstl"] == "S":
if (self.dicio["vl_slim_15_clcd"] * 0.5) > (self.dicio["vl_slim_15_ant"] * 0.5):
wgda_teto_slim_15 = self.dicio["vl_slim_15_clcd"] * 0.5
else:
wgda_teto_slim_15 = self.dicio["vl_slim_15_ant"] * 0.5
if (self.dicio["vl_slim_20_clcd"] * 0.5) > (self.dicio["vl_slim_20_ant"] * 0.5):
wgda_teto_slim_20 = self.dicio["vl_slim_20_clcd"] * 0.5
else:
wgda_teto_slim_20 = self.dicio["vl_slim_20_ant"] * 0.5
elif (self.dicio['cd_ntz_ocp'] in (4, 5, 6, 8)) or \
(self.dicio['cd_ntz_ocp'] == 13 and self.dicio["cd_ocp"] in (271, 272, 273, 310, 330)):
if self.dicio['cd_rsco_05'] in ("C", "D") or self.dicio['qt_tmp_ct_ano'] < 7:
wgda_teto_slim_15, wgda_teto_slim_20 = aplicarTeto(wgda_vlr_rndm_lqdo_ttl,
self.dicio["wgda_vl_pc40_rnd_parm_teto"],
self.dicio["wgda_vl_pc80_rnd_parm_teto"])
else:
wgda_teto_slim_15, wgda_teto_slim_20 = aplicarTeto(wgda_vlr_rndm_lqdo_ttl,
self.dicio["wgda_vl_pc40_rnd_parm_teto"],
self.dicio["wgda_vl_pc80_rnd_parm_teto"])
return wgda_teto_slim_15, wgda_teto_slim_20
clienteUniversitario
# Preparando Variáveis de Entrada
para a Função ANCS0126
self.anc0126 = {}
self.anc0126['ancs0126_funcao'] = 1
self.anc0126['ancs0126_cd_cli'] = self.dicio['cd_cli']
self.anc0126['ancs0126_cd_tip_pss'] = self.dicio['cd_tip_pss']
self.anc0126['ancs0126_cd_rsco_clcd'] = self.dicio['cd_rsco_05']
self.anc0126['ancs0126_mtdl_anl_crd'] =
self.dicio['cd_mtdl_anl_crd']
self.anc0126['ancs0126_vl_rtv_clcd'] =
self.dicio['vl_slim_20_clcd']
self.anc0126['ancs0126_vl_rtv_apvc'] = 0
self.anc0126['ancs0126_vl_min_crt_unit'] =
self.dicio['vl_min_crt_unit']
self.anc0126['ancs0126_vl_max_crt_unit'] =
self.dicio['vl_max_crt_unit']
# Recupera o maior entre os Sinais
de Alerta de Cartão de Crédito e
Cheque Especial
if self.dicio['cd_snl_avs_crt_crd'] > self.dicio['cd_snl_avs_chq_espl']:
self.anc0126['ancs0126_in_snl_alr'] = self.dicio['cd_snl_avs_crt_crd']
else:
self.anc0126['ancs0126_in_snl_alr'] = self.dicio['cd_snl_avs_chq_espl']
# Chamada para a SubRotina
ANCS0126
ancs0126_rc = anc.ancs0126(self)
if ancs0126_rc != 0:
pass
# Regra 1 - Cheque Especial
Universitário
if self.dicio['vl_slim_15_clcd'] <
self.dicio['vl_min_chq_unit']:
self.dicio['vl_slim_15_clcd'] =
self.dicio['vl_min_chq_unit']
self.dicio['vl_slim_15_apvd'] =
self.dicio['vl_min_chq_unit']
else:
self.dicio['vl_slim_15_apvd'] =
self.dicio['vl_slim_15_clcd']
# Regra 2 - Cartão de Crédito
Universitário
if self.dicio['vl_slim_20_clcd'] < self.dicio['vl_min_crt_unit']:
self.dicio['vl_slim_20_clcd'] = self.dicio['vl_min_crt_unit']
self.dicio['vl_slim_20_apvd'] = self.dicio['vl_min_crt_unit']
else:
self.dicio['vl_slim_20_apvd'] = self.dicio['vl_slim_20_clcd']
if self.anc0126['ancs0126_vl_rtv_apvc'] > self.dicio['vl_slim_20_apvd']:
self.dicio['vl_slim_20_apvd'] = self.anc0126['ancs0126_vl_rtv_apvc']
limiteMinimo()
limMinimo
# Inclusão regra aprovado ou autorizado, baseando-se na variavel: self.dicio['cd_status_cli']
if self.dicio['cd_status_cli'] == 2 or self.dicio['cd_status_cli'] == 1 :
if (self.dicio['vl_slim_20_clcd'] <= self.dicio['vl_min_crt_lmt']) and \
(self.dicio['vl_rend_lqdo_ttl'] >= self.dicio['vl_rnd_min_crt_lmt']) and \
(self.dicio['vl_rend_lqdo_ttl'] <= self.dicio['vl_rnd_max_crt_lmt']):
self.dicio['vl_slim_15_clcd'] = 0
self.dicio['vl_slim_20_clcd'] = 0
self.dicio['vl_slim_53_clcd'] = 0
self.dicio['vl_slim_178_clcd'] = 0
self.dicio['vl_slim_20_apvd'] = self.dicio['vl_min_crt_lmt']
self.dicio['ind_pbco_min'] = 'S'
if self.dicio['vl_rend_lqdo_ttl'] > self.dicio['vl_rnd_min_chq_lmt']:
if self.dicio['vl_slim_20_clcd'] < self.dicio['vl_min_crt_lmt']:
self.dicio['vl_slim_20_apvd'] = self.dicio['vl_max_crt_lmt']
self.dicio['ind_pbco_min'] = 'S'
if self.dicio['vl_slim_15_clcd'] < self.dicio['vl_min_chq_lmt']:
self.dicio['vl_slim_15_apvd'] = self.dicio['vl_min_chq_lmt']
self.dicio['ind_pbco_min'] = 'S'
procedimentos()
procIniciais()
# Instancias
# Instancias
te = TratarErro(self.caminho)
PERC_40 = 0.40
PERC_80 = 0.80
# Cheque Especial
# Cheque Especial
try:
self.dicio['vl_slim_15_ant'] =
int(self.dicio['vl_slim_15_ant'])
except:
te.getError('001')
# Cartão de Crédito
# Cartão de Crédito
try:
self.dicio['vl_slim_20_ant'] =
int(self.dicio['vl_slim_20_ant'])
except:
te.getError('002')
#Calculo de 40% e 80% da renda
parametrizada
# Calculo de 40% e 80% da renda
parametrizada
try:
self.dicio['wgda_vl_pc40_rnd_parm_teto']
= self.dicio['vl_ren_prtz_teto'] * PERC_40
except:
te.getError('003')
try:
self.dicio['wgda_vl_pc80_rnd_parm_teto']
= self.dicio['vl_ren_prtz_teto'] * PERC_80
except:
te.getError('004')
# Cheque Especial
# Cheque Especial
self.dicio['vl_slim_15_clcd'] =
self.dicio['vl_slim_15_ant']
self.dicio['vl_slim_15_apvd'] =
self.dicio['vl_slim_15_ant']
# Cartão de Crédito
# Cartão de Crédito
self.dicio['vl_slim_20_clcd'] =
self.dicio['vl_slim_20_ant']
self.dicio['vl_slim_20_apvd'] =
self.dicio['vl_slim_20_ant']
#
self.dicio['vl_slim_53_clcd'] =
self.dicio['vl_slim_53_ant']
self.dicio['vl_slim_53_apvd'] =
self.dicio['vl_slim_53_ant']
#
self.dicio['vl_slim_178_clcd'] =
self.dicio['vl_slim_178_utzd']
self.dicio['vl_slim_178_apvd'] =
self.dicio['vl_slim_178_utzd']
self.dicio['ind_pbco_min'] = 'N'
procFinais()
# Procedimentos Finais
limite_minimo = False
factor = DBFactor(self.caminho)
conn = factor.getConnect()
if self.dicio["cd_tip_bnf"] == 4:
crit_015 = 7008
crit_020 = 7009
else:
crit_015 = 7011
crit_020 = 7012
# Carregando a query de consulta
no DB2
fd = open(self.caminho + "/configuracao/query_procFinais.sql", 'r')
sql_file = fd.read()
fd.close()
# Recupera o valor mínimo
aprovado para Cheque Especial
query_015 = sql_file.format(crit_015)
gda_vl_min_015 = factor.getResult(conn, query_015)[0][3]
gda_vl_min_chq_apvd_015 = float(gda_vl_min_015.replace(',', '.'))
# Recupera o valor mínimo
aprovado para Cartão de Crédito
query_020 = sql_file.format(crit_020)
gda_vl_min_020 = factor.getResult(conn, query_020)[0][3]
gda_vl_min_crt_apvd_020 = float(gda_vl_min_020.replace(',', '.'))
if self.dicio['cd_crct_1682'] == 1:
self.dicio['vl_slim_15_apvd'] = 0
self.dicio['vl_slim_178_apvd'] = 0
self.dicio['vl_slim_53_apvd'] = 0
self.dicio['vl_grupo_62_apvd'] = 0
if self.dicio['vl_slim_15_apvd'] > 0 and \
self.dicio['vl_slim_15_apvd'] < gda_vl_min_chq_apvd_015:
self.dicio['vl_slim_15_apvd'] = gda_vl_min_chq_apvd_015
self.dicio['vl_grupo_62_apvd'] = gda_vl_min_chq_apvd_015
limite_minimo = True
if self.dicio['vl_slim_20_apvd'] > 0 and \
self.dicio['vl_slim_20_apvd'] < gda_vl_min_crt_apvd_020:
self.dicio['vl_slim_20_apvd'] = gda_vl_min_crt_apvd_020
self.dicio['vl_grupo_63_apvd'] = gda_vl_min_crt_apvd_020
limite_minimo = True
if limite_minimo:
if self.dicio['vl_grupo_62_apvd'] > self.dicio['vl_grupo_63_apvd']:
self.dicio['vl_bloco_11_apvd'] = self.dicio['vl_grupo_62_apvd']
else:
self.dicio['vl_bloco_11_apvd'] = self.dicio['vl_grupo_63_apvd']
PublicoGeral()
# Calculo do Limite Referencial
calcLimRef(self, "CHQ")
calcLimRef(self, "CRT")
# Verifica Público do Grupo de Trabalho de Fraude
verifGTFraude(self)
# Regra do Limite Minimo
if (self.dicio['in_bco_pstl'] == 'N') and (self.dicio['in_unit'] == 'N') and
(self.dicio['ind_pbco_fraude'] == 'N'):
limMinimo(self)
# Regra Renda até 2.500,00
if (self.dicio['ind_pbco_min'] == 'N') and (self.dicio['cd_sgm_anl'] == 55) and \
(self.dicio['in_bco_pstl'] == "N") and (self.dicio['in_unit'] == 'N'):
renda2500(self)
# Clientes Universitários
if self.dicio['in_unit'] == 'S':
uni.cliente_universitario(self)
# Aplica Sinal Alerta
aplicSnlAlerta(self, "CHQ")
aplicSnlAlerta(self, "CRT")
calc_apvd_far(self)
# Validação Limite Anterior e Teto -
Cartão de Crédito
if (self.dicio['vl_slim_20_ant'] <= self.dicio['vl_lim_ref_020']):
if self.dicio['vl_slim_20_apvd'] > self.dicio['vl_lim_ref_020']:
self.dicio['vl_slim_20_apvd'] = self.dicio['vl_lim_ref_020']
if (self.dicio['wgda_teto_slim_20'] > 0) and \
(self.dicio['vl_slim_20_apvd'] > self.dicio['wgda_teto_slim_20']):
self.dicio['vl_slim_20_apvd'] = self.dicio['wgda_teto_slim_20']
else:
self.dicio['vl_slim_20_apvd'] = self.dicio['ws_vl_apvd_far_020']
# Validação Limite Anterior e Teto -
Cheque Especial
if (self.dicio['vl_slim_15_ant'] <= self.dicio['vl_lim_ref_015']):
if self.dicio['vl_slim_15_apvd'] > self.dicio['vl_lim_ref_015']:
self.dicio['vl_slim_15_apvd'] = self.dicio['vl_lim_ref_015']
if (self.dicio['wgda_teto_slim_15'] > 0) and \
(self.dicio['vl_slim_15_apvd'] > self.dicio['wgda_teto_slim_15']):
self.dicio['vl_slim_15_apvd'] = self.dicio['wgda_teto_slim_15']
else:
self.dicio['vl_slim_15_apvd'] = self.dicio['ws_vl_apvd_far_015']
# Calcula o Grupos e Blocos
a.calcularGrupos(self)
ca.calcularBlocos(self)
raoSemPont()
#Início Clientes com RAO sem
pontualidade
# Variáveis de entrada
in_anot = self.dicio['in_anot']
in_ptdd = self.dicio['in_ptdd']
in_ctr_rao = self.dicio['in_ctr_rsct']
in_ctra_52_18 = self.dicio['in_ctra_52_18']
# Clientes com RAO sem
pontualidade
self.dicio['vl_slim_15_clcd'] =
self.dicio['vl_lim_clcd_rsct']
self.dicio['vl_slim_20_clcd'] =
self.dicio['vl_lim_clcd_rsct']
self.dicio['vl_slim_15_apvd'] =
self.dicio['vl_lim_clcd_rsct']
self.dicio['vl_slim_20_apvd'] =
self.dicio['vl_lim_clcd_rsct']
# Os valores de estabelecimento
para clientes com reescalonamento
são atribuídos no modulo
ANCNS527
renda2500(self)
if self.dicio['wgda_teto_slim_15'] > 0 and \
self.dicio['vl_slim_15_apvd'] > self.dicio['wgda_teto_slim_15']:
self.dicio['vl_slim_15_apvd'] = self.dicio['wgda_teto_slim_15']
if self.dicio['wgda_teto_slim_20'] > 0 and \ self.dicio['vl_slim_20_apvd'] >
self.dicio['wgda_teto_slim_20']: self.dicio['vl_slim_20_apvd'] =
self.dicio['wgda_teto_slim_20']
calc_apvd_far(self)
if self.dicio['wgda_teto_slim_15'] == 0:
self.dicio['vl_slim_15_apvd'] = self.dicio['ws_vl_apvd_far_015']
if self.dicio['wgda_teto_slim_20'] == 0:
self.dicio['vl_slim_20_apvd'] = self.dicio['ws_vl_apvd_far_020']
ca.calcularGrupos(self)
ca.calcularBlocos(self)
renda2500()
# Instâncias
te = TratarErro(self.caminho)
# Variáveis de Entrada
self.dicio['wgda_vl_ren_brto_cnvd'] = self.dicio['vl_ren_brto']
if (self.dicio['in_pgt'] == 1 or self.dicio['in_inss'] == 'S'):
if self.dicio['vl_ren_brto'] == 0:
try:
self.dicio['wgda_vl_ren_brto_cnvd'] = self.dicio['vl_rend_lqdo_ttl'] * 1.25
except:
te.getError('011')
if (self.dicio['wgda_vl_ren_brto_cnvd'] <= self.dicio['vl_ren_prtz_teto']) and \
(self.dicio['vl_rend_lqdo_ttl'] <= self.dicio['vl_ren_prtz_teto']) or \
(self.dicio['in_bco_pstl'] == 'S' and self.dicio['wgda_vl_ren_brto_cnvd'] <=
self.dicio['vl_ren_prtz_teto']):
self.dicio['wgda_teto_slim_15'],
self.dicio['wgda_teto_slim_20'],
self.dicio['wgda_vlr_rndm_lqdo_total'] = recomporRendaLqda(self)
recomporRendaLqda()
# Instância
te = TratarErro(self.caminho)
# Variáveis de Entrada
vl_utzd_consig_bb = self.dicio["vl_utzd_consig_bb"]
vl_utzd_consig_sfn = self.dicio["vl_utzd_consig_sfn"]
# Variáveis Auxiliares
wgda_vlr_rndm_lqdo_total =
self.dicio["vl_rend_lqdo_ttl"]
self.dicio["wgda_teto_slim_15"] = 0
self.dicio["wgda_teto_slim_20"] = 0
# Alteração Condição variável nível
88
if self.dicio["in_pgt"] == 1 or self.dicio["in_inss"] == 1:
try:
wgda_vlr_rndm_lqdo_total = (self.dicio["vl_rend_lqdo_ttl"] + \
vl_utzd_consig_bb + \
vl_utzd_consig_sfn)
except:
te.getError('006')
if wgda_vlr_rndm_lqdo_total <= self.dicio["vl_ren_prtz_teto"]:
self.dicio["wgda_teto_slim_15"], self.dicio["wgda_teto_slim_20"] =
apurarTeto(wgda_vlr_rndm_lqdo_total)
return wgda_teto_slim_15, wgda_teto_slim_20, wgda_vlr_rndm_lqdo_total
verifGtFraude()
Caso possua indicador de GT FRAUDE retorna uma lista com o indicador de público fraude
e o resultado do cálculo de limites.
Nos casos em que o cliente comprou renda de próprio punho e in_rlc_cli estiver em ('I', ' ')
os procedimentos_finais serão executados para cálculo do limite e retornados. Neste caso, a rotina que
estiver consumindo chamando função deverá retornar o resultado e finalizar a execução do programa.
Retorna:
* None: Quando in_frd não estiver em ("a", "A") ou
pbco_gt_fraudes igual a diferente de "S"
* List[str, None]: Quando não for detectado como público de fraude e os limites não forem
calculados.
* List[str, dict]: Quando cd_tip_cpvt_ren == 'F' e in_rlc_cli em ('I', ' ')
* List[str, tuple]: Demais casos (limite calculado)
# Instância
# Trata Cliente como
relacionamento completo caso
renda Liquida.
# Renda comprovação formal do
cliente (próprio punho).
# Renda comprovada (proventista ou não)
# Medida alternativa de declaração
quando o ir_frd não estiver ativa.
executar()
1.Cliente Anotação 348
if self.dicio['in_cli_anot_348'] == "S"
and self.dicio['in_cli_adpc_rhbl'] != 1:
2. Cliente Banco Postal
elif (self.dicio['in_bco_pstl'] == "S" and
self.dicio['cd_mtdl_anl_crd'] == 53 and \
self.dicio['cd_tip_bnf'] == 4) or
(self.dicio['in_bco_pstl'] == "S" and \
self.dicio['cd_sgm_anl'] == 55):
3. Cliente com Anotação igual a 4
elif self.dicio['in_anot'] == 4:
4. Clientes Reescalonamento
elif self.dicio['in_ctra_349'] == "S":
5. Cliente com Produto da Linha
7326
elif self.dicio['in_ctra_349_12'] ==
"S":
6. Clientes com RAO sem
Pontualidade
elif self.dicio['in_ctra_52_18'] == 1
or self.dicio['in_anot'] == 3 or \
(self.dicio['in_ctr_rsct'] == 1 and
self.dicio['in_ptdd'] == "N"):
rsp.raoSemPont(self)
7. Público Geral
else:
pbl.publicoGeral(self)
8. Regra de Redutor do Cartão de
Crédito (HU 507390)
Realizando Consultas
# Cria conexão
factor = DBFactor(self.caminho)
conn = factor.getConnect()
# Envia valores padrão para query
n_crrt = 7017
sem_prov_bb = 7018
renda_disp = 7019
renda_dcld = 7020
# Carrega a query de consulta no
DB2
fd = open(self.caminho +
"/configuracao/query_redutor_cartao_credito.sql",
'r')
sql_file = fd.read()
fd.close()
# Recupera o valor fator de ajuste
não correntista
if self.dicio['in_crrt'] == 'N':
query_ftr_ajs =
sql_file.format(aux_mtdl_red_cartao,
n_crrt)
aux_ftr_ajst_n_crrt =
factor.getResult(conn,
query_ftr_ajs)[0][3]
aux_ftr_ajst_n_crrt =
float(aux_ftr_ajst_n_crrt.replace(',',
'.'))
# Recupera o valor fator de ajuste
sem prov bb
if self.dicio['in_fun'] == 0 and self.dicio['in_pgt'] == 0 and self.dicio['in_unit'] == 'N':
query_ftr_ajs = sql_file.format(aux_mtdl_red_cartao, sem_prov_bb)
aux_ftr_ajst_sem_prov_bb = factor.getResult(conn, query_ftr_ajs)[0][3]
aux_ftr_ajst_sem_prov_bb = float(aux_ftr_ajst_sem_prov_bb.replace(',', '.'))
# Recupera o valor fator de ajuste
renda disp
if cpvt_renda in (27, 26, 32):
query_ftr_ajs = sql_file.format(aux_mtdl_red_cartao, renda_disp)
aux_ftr_ajs_renda_disp = factor.getResult(conn, query_ftr_ajs)[0][3]
aux_ftr_ajs_renda_disp = float(aux_ftr_ajs_renda_disp.replace(',', '.'))
# Recupera o valor fator de ajuste
renda dcld
if cpvt_renda in (18, 3, 7):
query_ftr_ajs = sql_file.format(aux_mtdl_red_cartao, renda_dcld)
aux_ftr_ajst_renda_dcld = factor.getResult(conn, query_ftr_ajs)[0][3]
aux_ftr_ajst_renda_dcld = float(aux_ftr_ajst_renda_dcld.replace(',', '.'))
# Executa calculo multiplicando
fatores de ajuste retirados da
query
self.dicio['vl_slim_20_apvd'] = self.dicio['vl_slim_20_apvd']
* aux_ftr_ajst_n_crrt * aux_ftr_ajst_sem_prov_bb *\
aux_ftr_ajs_renda_disp * aux_ftr_ajst_renda_dcld
# Calcula os Grupos e Blocos
ca.calcularGrupos(self)
ca.calcularBlocos(self)
# Executa a Procedimentos Finais
p.procFinais(self)
3. Parcelado
ProcParcelado
ProcessaParcelado()
Cálculos
calculoAgrup()
calcularGrupos()
Método para processar os cálculos
dos Agrupamentos
Parametros:
prdt = Nome do Produto
if prdt == "VCLO":
for tipo in ['apvd', 'clcd']:
if self.dicio['vl_slim_21_' + tipo] > self.dicio['vl_slim_117_' + tipo]:
self.dicio['vl_grupo_60_' + tipo] = self.dicio['vl_slim_21_' + tipo]
else:
self.dicio['vl_grupo_60_' + tipo] = self.dicio['vl_slim_117_' + tipo]
#INCLUIR REGRA DO ANCKCCF1-IN-AUX-EMER AQUI. FALTA INCLUIR A VARIAVEL DE RECONSIDERAÇÃO FUTURAMENTE.
if self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_grupo_60_apvd'] = 0
elif prdt == "RDEX":
for prd in [180, 181]:
self.dicio['vl_slim_' + str(prd) + '_apvd'] = self.dicio['vl_slim_' + str(prd) + '_utzd']
self.dicio['vl_slim_' + str(prd) + '_clcd'] = 0
for tipo in ['apvd', 'clcd']:
self.dicio['vl_grupo_65_' + tipo] = self.dicio['vl_slim_180_' + tipo] + \
self.dicio['vl_slim_181_' + tipo]
#INCLUIR REGRA DO ANCKCCF1-IN-AUX-EMER AQUI. FALTA INCLUIR A VARIAVEL DE RECONSIDERAÇÃO FUTURAMENTE.
if self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_grupo_65_apvd'] = 0
self.dicio['vl_slim_180_apvd'] = 0
self.dicio['vl_slim_181_apvd'] = 0
elif prdt == "RAO":
self.dicio['vl_pstc_rao_apvd'] = self.dicio['vl_ttl_pcl_rsct']
self.dicio['vl_pstc_rao_clcd'] = 0
self.dicio['vl_slim_111_apvd'] = self.dicio['vl_slim_111_utzd']
self.dicio['vl_slim_111_clcd'] = 0
self.dicio['vl_grupo_46_apvd'] = self.dicio['vl_slim_111_utzd']
self.dicio['vl_grupo_46_clcd'] = 0
#INCLUIR REGRA DO ANCKCCF1-IN-AUX-EMER AQUI. FALTA INCLUIR A VARIAVEL DE RECONSIDERAÇÃO FUTURAMENTE.
if self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_grupo_46_apvd'] = 0
self.dicio['vl_pstc_rao_apvd'] = 0
self.dicio['vl_slim_111_apvd'] = 0
elif prdt == "FUNCI":
# Denota o valor calculado e aprovado dos produtos 140, 228, 162, 157 e atribui nas variáveis do valor de grupo 64
# calculado e aprovado
# O código zera os maiores sublimites do grupo 64 aprovado e calculado
for tipo in ['apvd', 'clcd']:
self.dicio['maior_slim_funci_' + tipo] = 0
# O código compara os valores calculados e aprovados dos produtos 140, 157, 162, 228.
for prd in [140, 157, 162, 228]:
for tipo in ['apvd', 'clcd']:
if self.dicio['vl_slim_' + str(prd) + '_' + tipo] > self.dicio['maior_slim_funci_' + tipo]:
self.dicio['maior_slim_funci_' + tipo] = self.dicio['vl_slim_' + str(prd) + '_' + tipo]
for tipo in ['apvd', 'clcd']:
self.dicio['vl_grupo_64_' + tipo ] = self.dicio['maior_slim_funci_' + tipo]
# O código compara o valor calculado e aprovado do produto 157
#for tipo in ['apvd', 'clcd']:
# if self.dicio['vl_slim_157_' + tipo] > self.dicio['maior_slim_funci_' + tipo]:
# self.dicio['maior_slim_funci_' + tipo] = self.dicio['vl_slim_157_' + tipo]
# O valor do grupo 64 calculado recebe o valor da varável do maior sublimite do grupo 64 calculado
#for tipo in ['apvd', 'clcd']:
# self.dicio['vl_grupo_64_' + tipo ] = self.dicio['maior_slim_funci_' + tipo]
elif prdt == "ECF":
# Este trecho é responsavel por calcular o valor grupo 55 calculado e aprovado
# Inicializa as variaveis 'maior_slim_ecf_apvd' e 'maior_slim_ecf_clcd'
for tipo in ['apvd', 'clcd']:
self.dicio['maior_slim_ecf_' + tipo] = self.dicio['vl_slim_137_' + tipo]
# Compara o valor calculado e aprovado do produto 155 e 179
for prd in [155, 179]:
for tipo in ['apvd', 'clcd']:
if self.dicio['vl_slim_' + str(prd) + '_' + tipo] > self.dicio['maior_slim_ecf_' + tipo]:
self.dicio['maior_slim_ecf_' + tipo] = self.dicio['vl_slim_'+ str(prd) + '_' + tipo]
# Soma nas variaveis 'maior_slim_ecf_apvd' e 'maior_slim_ecf_clcd', o valor do aprovado e calculado do produto 171
for tipo in ['apvd', 'clcd']:
self.dicio['maior_slim_ecf_' + tipo] += self.dicio['vl_slim_171_' + tipo]
self.dicio['vl_grupo_55_' + tipo] = self.dicio['maior_slim_ecf_' + tipo]
elif prdt == "CDC":
# Este trecho é responsavel por calcular o valor grupo 45 calculado e aprovado
for tipo in ['apvd', 'clcd']:
self.dicio['maior_slim_cdc_' + tipo] = 0
#for prd in [83,115,116,119,129,130,131,142,156,156,157,159,160,161,163,173]:
for prd in [83,115,116,119,129,130,131,142,156,156,159,160,161,163,173]:
for tipo in ['apvd', 'clcd']:
if self.dicio['vl_slim_' + str(prd) + '_' + tipo] > self.dicio['maior_slim_cdc_'+ tipo]:
self.dicio['maior_slim_cdc_' + tipo] = self.dicio['vl_slim_' + str(prd) + '_' + tipo]
for tipo in ['apvd', 'clcd']:
self.dicio['vl_grupo_45_' + tipo] = self.dicio['maior_slim_cdc_' + tipo]
#INCLUIR REGRA DO ANCKCCF1-IN-AUX-EMER AQUI. FALTA INCLUIR A VARIAVEL DE RECONSIDERAÇÃO FUTURAMENTE.
if self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_grupo_45_apvd'] = 0
calcularBloco()
Método para processar o cálculo
do Blocos de Produtos calculado e
aprovado
# Inicialização das variaveis auxiliar
for tipo in ['apvd', 'clcd']:
self.dicio['maior_grupo_' + tipo] = 0
# Realiza a soma dos valores dos grupos 55 e 64 e armazena na variavel vl_grupo_5564_clcd e
# vl_grupo_5564_apvd
for tipo in ['apvd', 'clcd']:
self.dicio['vl_grupo_5564_' + tipo] = self.dicio['vl_grupo_55_' + tipo] + \
self.dicio['vl_grupo_64_' + tipo]
# Compara se o valor de grupo calculado ou aprovado é maior que o maior valor de grupo calculado ou aprovado
for prd in [45, 5564, 60]:
for tipo in ['apvd', 'clcd']:
if self.dicio['vl_grupo_' + str(prd) + '_' + tipo] > self.dicio['maior_grupo_' + tipo]:
self.dicio['maior_grupo_' + tipo] = self.dicio['vl_grupo_' + str(prd) + '_' + tipo]
# Somariza os valores dos Grupos e armazena na variavel vl_bloco_14_clcd e vl_bloco_14_apvd
for tipo in ['apvd', 'clcd']:
self.dicio['vl_bloco_14_' + tipo] = self.dicio['maior_grupo_' + tipo] + \
self.dicio['vl_grupo_46_' + tipo] + \
self.dicio['vl_grupo_65_' + tipo]
calculoFAR()
Método para calcular o valor da variável auxiliar do valor de prestação
FAR calculado e aprovado
class CalculoFar:
def __init__(self, dicio):
self.dicio = dicio
def calcularFar(self, prd):
'''
Metodo para calcular o valor da variável auxiliar do valor de prestação FAR calculado e aprovado
'''
if prd == '045':
self.dicio['ws_vl_pstc_far_clcd_045'] = int(self.dicio['vl_pstc_cdc_clcd']) * self.dicio['vl_ftr_ajst_pstc_pcld']
self.dicio['ws_vl_pstc_far_apvd_045'] = int(self.dicio['vl_pstc_cdc_apvd']) * self.dicio['vl_ftr_ajst_pstc_pcld']
elif prd == '021':
self.dicio['ws_vl_pstc_far_clcd_021'] = int(self.dicio['vl_pstc_vclo_clcd']) * self.dicio['vl_ftr_ajst_pstc_vclo']
self.dicio['ws_vl_pstc_far_apvd_021'] = int(self.dicio['vl_pstc_vclo_apvd']) * self.dicio['vl_ftr_ajst_pstc_vclo']
calculoPrtfCdc()
Método para processar o cálculo do portfolio CDC
from parcelado.regras.trataSLim import TrataSLim
from parcelado.calculos.calculoAgrup import CalculoAgrup
class CalculoPrtfCdc:
def __init__(self, dicio):
self.dicio = dicio
def calcularPrtfCdc(self):
# Instancia de Classes
ts = TrataSLim(self.dicio)
ca = CalculoAgrup(self.dicio)
# Calculo do valor da Prestacação CDC aprovado
self.dicio['vl_pstc_cdc_apvd'] = int(self.dicio['vl_pstc_cdc_clcd']) * \
(self.dicio['waux_pc_cdc'] / 100) * \
self.dicio['vl_ftr_ajst_pstc_pcld']
# Chamada para a aplicação de regras do Sublimite Aprovado CDC
ts.slimApvdCdc()
if self.dicio['cd_tip_cpvt_ren'] == 'C':
for prd in [21, 111, 117, 179, 180, 181]:
for tipo in ['apvd', 'clcd']:
self.dicio['vl_slim_' + str(prd) + '_' + tipo] = 0
# Chamada para o calculo dos Grupos
for grupo in ['CDC', 'ECF', 'RAO', 'FUNCI', 'VCLO', 'RDEX']:
ca.calcularGrupos(grupo)
# Chamada para o calculo do Bloco
ca.calcularBloco()
calculoPstc()
Método para processar os cálculos das prestações
Parametros:
ativo = Nome do Processo
class CalculoPstcCdc:
def __init__(self, dicio):
self.dicio = dicio
def calcularPstc(self, ativo):
'''
Metodo para processar os calculos das prestações
Parametros:
ativo = Nome do Processo
'''
if ativo == 'Corren':
self.dicio['vl_pstc_cdc_clcd'] = int(self.dicio['vl_ftr_demp'] * \
self.dicio['cd_ftr_rlc'] * \
self.dicio['vl_cfct_045'] * \
self.dicio['vl_smat_ren_pres_trans'])
elif ativo == 'Inss':
self.dicio['vl_pstc_cdc_clcd'] = int(self.dicio['vl_cfct_045'] * \
self.dicio['vl_smat_ren_pres_trans'])
elif ativo == 'Parc':
self.dicio['vl_pstc_cdc_clcd'] = int(self.dicio['vl_ftr_demp'] * \
self.dicio['vl_cfct_045'] * \
self.dicio['vl_ren_brto'] * \
self.dicio['waux_coef_ren'])
elif ativo == 'Proven':
self.dicio['vl_pstc_cdc_prtt'] = int(self.dicio['vl_ftr_demp'] * \
self.dicio['cd_ftr_rlc'] * \
self.dicio['vl_cfct_x_prtt'] * \
self.dicio['vl_smat_ren_clcd'])
elif ativo == 'Vclo':
self.dicio['vl_pstc_vclo_clcd'] = int(self.dicio['vl_ftr_demp'] * \
self.dicio['cd_ftr_rlc'] * \
self.dicio['vl_cfct_060'] * \
self.dicio['vl_rend_lqdo_ttl'])
calculoSlim()
Metodo para calcular o valor do Sub Limite.
Parametros:
Regra: server para realizar o calculo do sub-limite para ECF, se não informado, será
calculado apenas para os demais produtos.
1: ECF
2: Veiculo
None: Demais produtos
# CalculoSlim
class CalculoSlim:
def __init__(self, dicio):
self.dicio = dicio
def calcularSLim(self, regra = None):
if regra == 1:
# Cálculo sublimite ECF
self.dicio['aux_vl_slim'] = self.dicio['aux_pstc_slim'] * self.dicio['aux_mtp_slim']
if self.dicio['aux_vl_slim'] > self.dicio['aux_vl_lim_ref'] and self.dicio['cd_fuc'] == 1:
self.dicio['aux_vl_slim'] = self.dicio['aux_vl_lim_ref']
elif regra == 2:
# Cálculo sublimite de Veículos
for prd in [21, 117]:
for tipo in ['apvd', 'clcd']:
self.dicio['vl_slim_'+ str(prd) + '_' + tipo] = int(self.dicio['vl_pstc_vclo_' + tipo]) * \
self.dicio['vl_mtp_clc_slim_' + str(prd)]
else:
# Cálculos sublimite - demais
produtos
self.dicio['aux_red_slim'] = 1
# O código compara se a variável auxiliar de cordialidade de sublimite é igual a 161, \
para calcular o valor da variável auxiliar de valor de sublimite
if self.dicio['aux_cd_slim'] == 161:
self.dicio['aux_vl_slim'] = self.dicio['aux_pstc_slim'] * self.dicio['aux_mtp_slim'] * \
self.dicio['aux_red_slim'] * self.dicio['aux_far_slim']
else:
self.dicio['aux_vl_slim'] = self.dicio['aux_pstc_slim'] * self.dicio['aux_mtp_slim'] * \
self.dicio['aux_red_slim'] * self.dicio['aux_far_slim'] * \
self.dicio['aux_redt_vcli']
# Se a variável auxiliar do valor de sublimite for maior que a variável auxiliar de
sublimite do valor limite referencia e se o caso for de pessoa física, a variável
auxiliar do valor de sublimite recebe o valor da variável do valor de limite
referencia
if self.dicio['aux_vl_slim'] > self.dicio['aux_vl_lim_ref'] and self.dicio['cd_fuc'] == 1:
self.dicio['aux_vl_slim'] = self.dicio['aux_vl_lim_ref']
if self.dicio['aux_mtp_slim'] > self.dicio['gda_maior_mtp'] and self.dicio['aux_vl_slim'] > 0:
self.dicio['wix_crit'] = 0
for i in range (0, self.dicio['qt_reg_slim_rnv']):
if self.dicio['cd_slim_rnv'][i] == self.dicio['aux_cd_slim']:
self.dicio['gda_maior_mtp'] = self.dicio['aux_mtp_slim']
break
calculoVlTeto()
Método para processar o cálculo do Valor Teto
class CalculoVlTeto():
def __init__(self, dicio):
self.dicio = dicio
if self.dicio['cd_mtdl_anl_crd'] == 51:
self.pc1, self.pc2, self.pc3 = 0.10, 0.15, 0.20
elif self.dicio['cd_mtdl_anl_crd'] in (52,53):
self.pc1, self.pc2, self.pc3 = 0.07, 0.10, 0.15
def calcularVlTeto(self):
if self.dicio['wgda_vlr_rndm_lqdo_total'] <= self.dicio['wgda_vl_pc40_rnd_parm_teto']:
self.dicio['wgda_teto_pstc_cdc'] = self.dicio['wgda_vlr_rndm_lqdo_total'] * self.pc1
elif self.dicio['wgda_vlr_rndm_lqdo_total'] <= self.dicio['wgda_vl_pc80_rnd_parm_teto']:
self.dicio['wgda_teto_pstc_cdc'] = self.dicio['wgda_vlr_rndm_lqdo_total'] * self.pc2
elif self.dicio['wgda_vlr_rndm_lqdo_total'] > self.dicio['wgda_vl_pc80_rnd_parm_teto']:
self.dicio['wgda_teto_pstc_cdc'] = self.dicio['wgda_vlr_rndm_lqdo_total'] * self.pc3
else:
self.dicio['wgda_teto_pstc_cdc'] = 0
Módulos
ancsc246
cargaTabRet()
class CargaTabRet:
def __init__(self, dicio):
self.dicio = dicio
self.dicio['crit_cd_seq'] = []
self.dicio['in_rgr_atv'] = []
self.dicio['cd_crit'] = []
self.dicio['nr_seql_crit'] = []
self.dicio['in_crit_atv'] = []
self.dicio['cd_tip_ctu'] = []
self.dicio['tx_ctu'] = []
self.dicio['vl_flo_crit'] = []
self.dicio['vl_alf_crit'] = []
def carregarTabRet(self, tipo, res_psq, pos):
if tipo != 3:
self.dicio['in_rgr_atv'].append(res_psq[0])
if tipo == 1:
if pos == 72:
self.dicio['gda_seql_crit_rech'] = res_psq[2]
self.dicio['gda_nr_crit_rech'] = res_psq[1]
self.dicio['ind_fim'] = 'S' # Sair do laço?
else:
self.dicio['gda_seql_crit_rech'] = 0
self.dicio['gda_nr_crit_rech'] = 0
elif tipo == 3:
self.dicio['ic_tab_opr'] = pos
if self.dicio['faixa_tab_opr']:
if pos == 72:
self.dicio['ind_fim'] = 'S'
# Calculo
self.dicio['crit_cd_seq'].append((res_psq[1] * 1000) + res_psq[2])
self.dicio['cd_crit'].append(res_psq[1])
self.dicio['nr_seql_crit'].append(res_psq[2])
self.dicio['in_crit_atv'].append(res_psq[5])
self.dicio['cd_tip_ctu'].append(res_psq[3])
self.dicio['tx_ctu'].append(res_psq[4])
if self.dicio['cd_tip_ctu'][pos] == 3:
self.dicio['vl_flo_crit'].append(str(res_psq[4]).replace(" ", ""))
else:
self.dicio['vl_alf_crit'].append(str(res_psq[4]).replace(" ", ""))
psqInformacao()
from config_erro.trataErro import TratarErro
from db.dbFactor import DBFactor
class PesquisaInformacao:
def __init__(self, dicio):
self.dicio = dicio
self.caminho = dicio['caminho']
def lerQuery(self, id):
'''
Metodo para a leitura das Querys em SQL
'''
# Abre o arquivo com a query
arq = open(self.caminho + "/configuracao/query_psqC{0}.sql".format(id), "r")
sql_query = arq.read()
arq.close()
return sql_query
def montaQuery(self, id):
'''
Metodo para formatar as Querys em SQL
'''
query = self.lerQuery(id)
if id in [1, 9]:
return query.format(self.dicio['cd_mtdl_e'], \
self.dicio['cd_rgr_e'], \
self.dicio['gda_nr_crit_rech'], \
self.dicio['gda_seql_crit_rech'])
elif id == 2:
return query.format(self.dicio['aux_cd_mtdl'], self.dicio['aux_cd_rgr'], self.dicio['cd_crit_e'])
elif id in [3, 10]:
return query.format(self.dicio['aux_cd_mtdl'], self.dicio['aux_cd_rgr'], self.dicio['cd_crit_e'])
elif id == 4:
return query.format(self.dicio['aux_cd_mtdl'], self.dicio['aux_cd_rgr'])
elif id in [5, 6, 7, 8]:
return query.format(self.dicio['aux_cd_mtdl'])
elif id == 11:
return query.format(self.dicio['aux_cd_mtdl'], \
self.dicio['aux_cd_rgr'], \
self.dicio['cd_crit_e'], \
self.dicio['gda_nr_seql_crit_loc'], \
self.dicio['gda_nr_seql_cmps'])
def pesquisarCriterio(self, id):
factor = DBFactor(self.caminho)
#
self.dicio['gda_cd_crit'] = []
self.dicio['gda_nr_seql_cmps'] = []
self.dicio['gda_in_rgr_atv'] = []
self.dicio['gda_nr_seql_crit'] = []
self.dicio['gda_cd_tip_ctu'] = []
self.dicio['gda_tx_ctu'] = []
self.dicio['gda_in_crit_atv'] = []
# Criando a conexão com o banco de dados
conn = factor.getConnect()
# Consultando o banco de dados
query_psq = self.montaQuery(id)
res_psq = factor.getResult(conn, query_psq)
return res_psq
def pesquisarMetodologia(self, psq):
# Cria a conexão com o Db2
factor = DBFactor(self.caminho)
conn = factor.getConnect()
self.dicio['cd_mtdl_anl_aux'] = []
self.dicio['qt_reg'] = 0
if psq == "mtld":
query_psq = self.montaQuery(5)
elif psq == "vgt":
query_psq = self.montaQuery(6)
elif psq == "pnd":
query_psq = self.montaQuery(7)
elif psq == "hst":
query_psq = self.montaQuery(8)
elif psq == "rgr":
query_psq = self.montaQuery(4)
res_psq = factor.getResult(conn, query_psq)
if psq in ("mtld", "vgt", "pnd", "hst"):
for i in range(0, len(res_psq)):
self.dicio['cd_mtdl_anl_aux'].append(res_psq[i][0])
self.dicio['qt_reg'] += 1
if psq == "rgr":
if len(res_psq) > 0:
self.dicio['qt_reg'] = res_psq[0][0]
def pesquisarCriterio2(self, psq):
'''
Metodo traduzido da subrotina ANCSC246: 104000-PSQ-CRITERIO-02
'''
# Carregando a query de consulta no DB2
query_psq = self.montaQuery(11)
# Consultando o DB2
res = factor.getResult(conn, query_psq)
if len(res) > 0:
for i in range(0, len(res)):
self.dicio['qt_reg'] += 1
self.dicio['cd_crit'][i] = self.dicio['aux_cd_crit']
self.dicio['nr_seql_crit'][i] = self.dicio['gda_nr_seql_crit_loc']
self.dicio['cd_tip_ctu'][i] = res[i][0] # self.dicio['gda_cd_tip_ctu']
self.dicio['tx_ctu'][i] = res[i][1] # self.dicio['gda_tx_ctu']
self.dicio['in_crit_atv'][i] = res[i][2] # self.dicio['gda_in_crit_atv']
if res[i][0] == 3:
self.dicio['vl_flo_crit'][1] = res[i][1]
else:
self.dicio['vl_alf_crit'][1] = res[i][1]
def pesquisarCriterioPend(self):
'''
Metodo traduzido da rotina ANCSC246: 105000-PSQ-CRITERIOS-PEND
'''
# Chama cursor
query_psq = self.montaQuery(3)
res = factor.getResult(conn, query_psq)
if len(res) != 0: #self.dicio['aux_sqlcode_normal']:
self.dicio['ind_fim'] = 'N' # retirar?
ix = 0 # retirar?
for ix in range(0, len(res)):
self.dicio['gda_in_rgr_atv'].append(res[ix][0])
self.dicio['gda_cd_crit'].append(res[ix][1])
self.dicio['gda_nr_seql_crit'].append(res[ix][2])
self.dicio['gda_cd_tip_ctu'].append(res[ix][3])
self.dicio['gda_tx_ctu'].append(res[ix][4])
self.dicio['gda_in_crit_atv'].append(res[ix][5])
if self.dicio['in_ret_bxd'] == 'N' and self.dicio['gda_in_rgr_atv'] == 'N':
break # self.dicio['ind_fim'] = 'S' # retirar?
if self.dicio['in_ret_bxd'] == 'S' or self.dicio['gda_in_rgr_atv'] == 'S' and self.dicio['gda_crit_atv'] == 'S':
# Por parâmetro, passar o "ix" para a função 105001.
#PERFORM 105001-CARGA-TAB-RET
ctr.carregarTabRet('C3', ) # Precisamos descobrir qual o valor do segundo parametro que será encaminhado aqui dentro
#if len(res) == 0: # retirar?
# return # self.dicio['ind_fim'] = 'S' # retirar?
def pesquisarSeqlCrit(self):
query_psq = self.montaQuery(10)
res = factor.getResult(conn, query_psq)
if len(res) != 0:
self.dicio['qtd_reg'] = 1
self.dicio['nr_seql_crit'][0].append(cursor[i][0])
else:
self.dicio['nr_seql_crit'][0].append(0)
rotinaPrincipal()
from parcelado.modulos.ancsc246.psqInformacao import PesquisaInformacao
class RotinaPrincipal():
def __init__(self, dicio):
self.dicio = dicio
def rotina_Principal(self):
#Instanciando classes
pi = PesquisaInformacao(self.dicio)
#self.dicio['sql_init_flag'] = 0
#self.dicio['aux_cd_mtdl'] = self.dicio['cd_mtdl_e']
#self.dicio['aux_cd_rgr'] = self.dicio['cd_rgr_e']
if self.dicio['cd_fuc'] == 1:
if self.dicio['cd_crit_e'] > 0:
# TODO perform 101000_psq_crit_especifico thru 101999_fim
# Aguardando a definição do arquivo psqCriterio.py para incluir essa chamada
pi.pesquisarCriterioEspo()
else:
if self.dicio['in_ret_bxd'] == 'S':
return pi.pesquisarCriterio(1)
else:
return pi.pesquisarCriterio(9)
elif self.dicio['cd_fuc'] in (2, 4):
#TODO perform 103000_psq_criterio_01 thru 103000_fim
# Aguardando a definição do arquivo psqCriterio.py para incluir essa chamada
pi.pesquisarCriterio1()
elif self.dicio['cd_fuc'] == 3:
pi.pesquisarCriterioPend()
elif self.dicio['cd_fuc'] == 5:
pi.pesquisarMetodologia('mtdl')
elif self.dicio['cd_fuc'] == 6:
pi.pesquisarMetodologia('vgt')
elif self.dicio['cd_fuc'] == 7:
pi.pesquisarMetodologia('pnd')
elif self.dicio['cd_fuc'] == 8:
pi.pesquisarMetodologia('hst')
elif self.dicio['cd_fuc'] == 9:
pi.pesquisarSeqlCrit()
elif self.dicio['cd_fuc'] == 10:
pi.pesquisarMetodologia('rgr')
ancsf159
ancsf159()
from parcelado.modulos.ancsf159.buscaMci import BuscaMci
from parcelado.modulos.ancsf159.inicializarVrvTrb import InicializaVrvTrb
from parcelado.modulos.ancsf159.pesquisarEmpregador import PesquisarEmpregador
from parcelado.modulos.ancsf159.calculoPrestacao import CalculoPrestacao
class ANCSF159():
def __init__(self, dicio):
self.dicio = dicio
def processar(self):
# Instancias de classe
ivt = InicializaVrvTrb(self.dicio)
bm = BuscaMci(self.dicio)
pe = PesquisarEmpregador(self.dicio)
cp = CalculoPrestacao(self.dicio)
ivt.inicializa_Vrv_Trab()
bm.buscarMCI()
pe.pesquisarEpgrDfrt30Pc()
cp.calcularPstcPF()
buscaMci()
Classe responsável por carregar os MCIs do
INSS, BB, PREVIDÊNCIA e Exército
import os
class BuscaMci():
def __init__(self, dicio):
self.dicio = dicio
def buscarMCI(self):
'''
Classe responsavel por carregar os MCIs do INSS, BB, PREVIDENCIA e Exercito
'''
self.dicio['cd_id_inss'] = 1
self.dicio['cd_id_bb'] = 2
self.dicio['cd_id_previ'] = 3
self.dicio['cd_id_exercito'] = 4
if os.environ['AMBIENTE'] in ['MODELAGEM', 'DESENVOLVIMENTO']:
# 1 - INSS
self.dicio['cd_mci_inss'] = 103824079
self.dicio['cd_cvn_inss'] = 0
# 2 - BB
self.dicio['cd_mci_bb'] = 903485186
self.dicio['cd_cvn_bb'] = 0
# 3 - PREVI
self.dicio['cd_mci_previ'] = 602907665
self.dicio['cd_cvn_previ'] = 0
# 4 - EXERCITO
self.dicio['cd_mci_exercito'] = 690001155
self.dicio['cd_cvn_exercito'] = 134486
elif os.environ['AMBIENTE'] == 'HOMOLOGAÇÃO':
# 1 - INSS
self.dicio['cd_mci_inss'] = 208961759
self.dicio['cd_cvn_inss'] = 0
# 2 - BB
self.dicio['cd_mci_bb'] = 130965148
self.dicio['cd_cvn_bb'] = 0
# 3 - PREVI
self.dicio['cd_mci_previ'] = 178998134
self.dicio['cd_cvn_previ'] = 0
# 4 - EXERCITO
self.dicio['cd_mci_exercito'] = 248940924
self.dicio['cd_cvn_exercito'] = 296598
else:
# 1 - INSS
self.dicio['cd_mci_inss'] = 103824079
self.dicio['cd_cvn_inss'] = 0
# 2 - BB
self.dicio['cd_mci_bb'] = 903485186
self.dicio['cd_cvn_bb'] = 0
# 3 - PREVI
self.dicio['cd_mci_previ'] = 100186582
self.dicio['cd_cvn_previ'] = 0
# 4 - EXERCITO
self.dicio['cd_mci_exercito'] = 105907575
self.dicio['cd_cvn_exercito'] = 296598
calculoPrestacao()
from parcelado.modulos.ancsf159.pesquisarDados import PesquisarDados
from parcelado.modulos.ancsf159.selecionarRndCvn import SelecionarRndCvn
from parcelado.modulos.ancsf159.verificarZeraPrestacao import VerificarZeraPrestacao
from parcelado.modulos.ancsf159.calculoRenda import CalculoRenda
from dateutil.relativedelta import relativedelta
from datetime import datetime
class CalculoPrestacao:
def __init__(self, dicio):
self.dicio = dicio
def calcularPstcFinal(self):
self.dicio['vl_pstc_funci_clcd'] = int(self.dicio['gda_vl_rnd_funci_seld'] * 0.30 * \
self.dicio['vl_cfct_055'])
if self.dicio['vl_pstc_funci_clcd'] > self.dicio['vl_lim_ref_055']:
self.dicio['vl_pstc_funci_clcd'] = self.dicio['vl_lim_ref_055']
self.dicio['vl_pstc_funci_apvd'] = int(self.dicio['vl_pstc_funci_clcd'] * self.dicio['vl_ftr_ajst_pstc_cgn_flh'])
self.dicio['vl_pstc_bb_org'] = self.dicio['vl_pstc_funci_clcd']
self.dicio['vl_pstc_demais'] = int(self.dicio['gda_vl_pstc_ecf_seld'] * self.dicio['vl_cfct_055'])
if self.dicio['vl_pstc_demais'] > self.dicio['vl_lim_ref_055']:
self.dicio['vl_pstc_demais'] = self.dicio['vl_lim_ref_055']
self.dicio['vl_pstc_demais_org'] = self.dicio['vl_pstc_demais']
self.dicio['vl_pstc_ttl_ecf_clcd'] = self.dicio['vl_pstc_demais']
if self.dicio['vl_pstc_ttl_ecf_clcd'] > self.dicio['vl_lim_ref_055']:
self.dicio['vl_pstc_ttl_ecf_clcd'] = self.dicio['vl_lim_ref_055']
self.dicio['vl_pstc_ttl_ecf_apvd'] = int(self.dicio['vl_pstc_ttl_ecf_clcd'] * self.dicio['vl_ftr_ajst_pstc_cgn_flh'])
self.dicio['vl_pstc_ttl_ecf_org'] = self.dicio['vl_pstc_ttl_ecf_apvd']
if self.dicio['waux_pstc_slim_171'] > self.dicio['vl_lim_ref_055']:
self.dicio['waux_pstc_slim_171'] = self.dicio['vl_lim_ref_055']
self.dicio['vl_pstc_crt_clcd'] = int(self.dicio['waux_pstc_slim_171'])
self.dicio['vl_pstc_crt_apvd'] = int(self.dicio['waux_pstc_slim_171'] * self.dicio['vl_ftr_ajst_pstc_cgn_flh'])
if self.dicio['in_cli_anot_348'] == 'S' and self.dicio['in_cli_adpc_clireab'] != 1:
self.dicio['vl_pstc_funci_clcd'] = 0
self.dicio['vl_pstc_bb_org'] = 0
self.dicio['ic_ajst_cvn_ecf'] = self.dicio['waux_ic_ajst_cvn_ecf_seld']
self.dicio['ic_ajst_cvn_crt'] = self.dicio['waux_ic_ajst_cvn_crt_seld']
self.dicio['ic_ajst_cvn_sal'] = self.dicio['waux_ic_ajst_cvn_sal_seld']
self.dicio['ic_mtp_cvn_ecf'] = self.dicio['waux_ic_mtp_seld_ecf']
self.dicio['ic_mtp_cvn_crt'] = self.dicio['waux_ic_mtp_seld_crt']
self.dicio['ic_mtp_cvn_sal'] = self.dicio['waux_ic_mtp_seld_sal']
self.dicio['vl_max_cvn_ecf'] = self.dicio['waux_vl_max_cvn_ecf_seld']
self.dicio['vl_max_cvn_crt'] = self.dicio['waux_vl_max_cvn_crt_seld']
self.dicio['vl_max_cvn_sal'] = self.dicio['waux_vl_max_cvn_sal_seld']
def calcularPstcSgm13(self):
'''
Transcrição do Modulo 110000-CALCULO-PSTC-SGM-13
'''
# Instancia de classe
pd = PesquisarDados()
pd.pesquisarDadosConvenio(self.dicio[''], 137)
self.dicio['vl_pstc_ttl_ecf_clcd'] = int(self.dicio['vl_bnf'] * 0.30 * \
self.dicio['cfct_033'] * \
self.dicio['waux_ic_red_pstc'])
if self.dicio['vl_pstc_ttl_ecf_clcd'] > self.dicio['lim_ref_055']:
self.dicio['vl_pstc_ttl_ecf_clcd'] = self.dicio['lim_ref_055']
self.dicio['vl_pstc_ttl_ecf_org'] = self.dicio['vl_pstc_ttl_ecf_clcd']
self.dicio['vl_pstc_ttl_ecf_apvd'] = self.dicio['vl_pstc_ttl_ecf_clcd']
self.dicio['ic_ajst_cvn_ecf'] = self.dicio['ic_ajst_cvn']
self.dicio['ic_mtp_cvn_ecf'] = self.dicio['waux_ic_mtp_cvn']
self.dicio['vl_max_cvn_ecf'] = self.dicio['waux_vl_max_cvn']
pd.pesquisarDadosConvenio(self.dicio['cd_mci_inss'], 171)
self.dicio['ic_ajst_cvn_crt'] = self.dicio['waux_ic_ajst_cvn']
self.dicio['ic_mtp_cvn_crt'] = self.dicio['waux_ic_mtp_cvn']
self.dicio['vl_max_cvn_crt'] = self.dicio['waux_vl_max_cvn']
def calcularPstcPF(self):
# Declarando Variáveis Auxiliares
#self.dicio['waux_dta_atual_alpha'] = datetime.now().strftime("%Y-%m-%d")
#self.dicio['waux_dta_atual'] = datetime.today().strftime("%Y-%m-%d")
self.dicio['waux_dta_a2anos'] = (datetime.today() + relativedelta(years=-2)).strftime("%Y-%m-%d")
# Instancia de classes
src = SelecionarRndCvn(self.dicio)
zp = VerificarZeraPrestacao(self.dicio)
cr = CalculoRenda(self.dicio)
# Chamadas para as funções
cr.calcularRndLiqPres()
src.selecionarRndCvn()
self.calcularPstcFinal()
zp.verifZeraPrestacao()
calculoRenda()
cargaRendaValida()
inicializarVrvTrb()
pesquisarDados()
pesquisarEmpregador()
selecionarRenda()
selecionarRndCvn()
verificarZeraPrestacao()
Regras
apuraTeto()
recompRendaLqda()
redMtpSlim083()
regraCMP()
regraPstcEcfFunci()
regrasPstc()
# RegrasPstc
from parcelado.calculos.calculoPstc import CalculoPstcCdc
from parcelado.regras.trataSnlAlerta import TrataSnlAlerta
from parcelado.regras.recompRendaLqda import RecompRendaLqda
from parcelado.regras.zeraPrestacoes import ZeraPrestacoes
class RegrasPstc:
def __init__(self, dicio):
self.dicio = dicio
# aplicaRegraPstcCorren
# Instancias de Classes
cp = CalculoPstcCdc(self.dicio)
aa = TrataSnlAlerta(self.dicio)
rl = RecompRendaLqda(self.dicio)
zp = ZeraPrestacoes(self.dicio)
self.dicio['waux_vl_2slr_min'] = self.dicio['vl_slr_min'] * 2
cp.calcularPstc('Corren')
if self.dicio['vl_pstc_cdc_clcd'] > 9999999.99:
self.dicio['vl_pstc_cdc_clcd'] = 9999999.99
if self.dicio['vl_pstc_cdc_clcd'] > self.dicio['vl_lim_ref_045']:
self.dicio['vl_pstc_cdc_clcd'] = self.dicio['vl_lim_ref_045']
self.dicio['vl_pstc_cdc_clcd'] += self.dicio['vl_pstc_cdc_prtt']
if self.dicio['cd_sgm_anl'] != 25 and self.dicio['in_bco_pstl'] != 'N':
self.dicio['wgda_vl_ren_brto'] = self.dicio['vl_ren_brto']
if self.dicio['in_pgt'] or self.dicio['in_inss']:
if self.dicio['vl_ren_brto'] == 0:
self.dicio['wgda_vl_ren_brto'] = self.dicio['vl_rend_lqdo_ttl'] * 1.25
if (self.dicio['wgda_vl_ren_brto'] <= self.dicio['vl_ren_prtz_teto']) and \
(self.dicio['vl_rend_lqdo_ttl'] <= self.dicio['vl_ren_prtz_teto']):
# Chamada para Recompe Renda Liquida
rl.recomp_Renda_Lqda()
aa.trata_Snl_Alerta()
if self.dicio['vl_pstc_cdc_apvd'] > self.dicio['wgda_teto_pstc_cdc'] and \
self.dicio['wgda_teto_pstc_cdc'] > 0:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['wgda_teto_pstc_cdc']
if self.dicio['vl_pstc_cdc_apvd'] > self.dicio['vl_lim_ref_045']:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['vl_lim_ref_045']
# Chamada para Zera Prestacoes
zp.zera_Prestacoes()
# aplicaRegraPstcInss
# aplicaRegraPstcParc
# aplicaRegraPstcProven
# aplicarRegraPstcVclo
trataSLim()
__init__()
processaCalculo()
def processaCalculo(self, prd, tp = None):
# Instanciando Classe
cs = CalculoSlim(self.dicio)
# Se o parameto tp for informado, montará uma lista com um argumento apenas
lst_tipo = []
if tp is None:
lst_tipo = ['apvd', 'clcd']
else:
lst_tipo.append(tp)
for tipo in lst_tipo:
if prd in [137, 155, 179]:
if tipo == 'apvd':
self.dicio['aux_pstc_slim'] = int(self.dicio['vl_pstc_ecf_demais']) * \
self.dicio['vl_ftr_ajst_pstc_cgn_flh']
else:
self.dicio['aux_pstc_slim'] = int(self.dicio['vl_pstc_ecf_demais'])
elif prd == 171:
self.dicio['aux_pstc_slim'] = int(self.dicio['vl_pstc_crt_' + tipo])
elif prd in [140, 157, 162, 228]:
self.dicio['aux_pstc_slim'] = int(self.dicio['vl_pstc_fun_bb_' + tipo])
elif prd in [116, 119, 131, 142, 156, 159, 160, 161, 163, 173]:
self.dicio['aux_pstc_slim'] = int(self.dicio['vl_pstc_cdc_' + tipo])
elif prd in [83, 115]:
self.dicio['aux_pstc_slim'] = int(self.dicio['ws_psct_cdc_' + str(prd) + '_c'])
self.dicio['aux_mtp_slim'] = self.dicio['vl_mtp_clc_slim_' + str(prd)]
self.dicio['aux_cd_slim'] = prd
self.dicio['aux_far_slim'] = 1
self.dicio['aux_vl_lim_ref'] = self.dicio['vl_lim_ref_' + str(prd)]
if prd == 160 and tipo == 'apvd':
self.dicio['aux_redt_vcli'] = self.dicio['redt_slim_' + str(prd)]
elif prd in [83, 115, 116, 142] and tipo == 'apvd':
self.dicio['aux_redt_vcli'] = self.dicio['redt_slim_' + str(prd) + '_vs_cli']
else:
self.dicio['aux_redt_vcli'] = 1
if prd in self.ecf:
cs.calcularSLim(1)
else:
cs.calcularSLim()
if (prd in [137, 140, 155, 179, 228]) and (tipo == 'apvd'):
self.dicio['vl_slim_' + str(prd) + '_' + tipo] = self.dicio['aux_vl_slim'] * \
self.dicio['vl_ftr_ajst_slim_' + str(prd)]
else:
self.dicio['vl_slim_' + str(prd) + '_' + tipo] = self.dicio['aux_vl_slim']
slim_Vclo()
def slim_Vclo(self):
# Para cliente banco postal, slim veículo igual a zero
# Regra enviada no dia 22/10/2014. Liberar os valores Veiculos
# nao considerando a regra de bco postal (565)
# OBS No book a variavel self.dicio['in_rcdr'] está setada com 12
# Aqui ele faz uma comparação para saber se a execução é em Batch
# Instancia de Classe
cs = CalculoSlim(self.dicio)
# OBS A variavel self.dicio['sem_bnf'] está setada como 4
if self.dicio['in_bco_pstl'] == 'S' and (self.dicio['cd_sgm_anl'] == 19 or \
(self.dicio['cd_mtdl_anl_crd'] == 52 and self.dicio['cd_tip_bnf'] == 4)):
for prd in [21, 117]:
for tipo in ['apvd', 'clcd']:
self.dicio['vl_slim_' + str(prd) + '_' + tipo ] = 0
self.dicio['vl_pstc_vclo_'+ tipo] = 0
elif self.dicio['qt_idd'] > 85:
for prd in [21, 117]:
for tipo in ['apvd', 'clcd']:
self.dicio['vl_slim_' + str(prd) + '_' + tipo ] = 0
self.dicio['vl_pstc_vclo_'+ tipo] = 0
# Calculo valor sublimite calculado e aprovado para os produtos 21 e 117 - Veiculo
cs.calcularSLim(2)
for prd in [21, 117]:
# Validação do valor sublimite calculado e aprovado para os produtod 21 e 117 - Veiculo
# Calculado
if self.dicio['vl_slim_' + str(prd) + '_clcd'] > self.dicio['vl_lim_ref_' + str(prd)]:
self.dicio['vl_slim_' + str(prd) + '_clcd'] = self.dicio['vl_lim_ref_' + str(prd)]
# Aprovado
if self.dicio['vl_slim_' + str(prd)+ '_utzd'] > self.dicio['vl_slim_' + str(prd) + '_apvd']:
self.dicio['vl_slim_' + str(prd) + '_apvd'] = self.dicio['vl_slim_' + str(prd) + '_utzd']
if self.dicio['vl_slim_' + str(prd) +'_utzd'] > self.dicio['vl_lim_ref_' + str(prd)]:
if self.dicio['vl_slim_' + str(prd) + '_apvd'] > self.dicio['vl_slim_' + str(prd) + '_utzd']:
self.dicio['vl_slim_' + str(prd) +'_apvd'] = self.dicio['vl_slim_' + str(prd) + '_utzd']
else:
if self.dicio['vl_slim_' + str(prd) + '_apvd'] > self.dicio['vl_lim_ref_' + str(prd)]:
self.dicio['vl_slim_' + str(prd) + '_apvd'] = self.dicio['vl_lim_ref_' + str(prd)]
if self.dicio['cd_rsco_05'] == 'E' and self.dicio['cd_rsco_05_prvr'] == 'D':
for prd in [21, 117]:
for tipo in ['apvd', 'clcd']:
self.dicio['vl_slim_' + str(prd) + '_' + tipo ] = 0
#INCLUIR REGRA DO ANCKCCF1-IN-AUX-EMER AQUI. FALTA INCLUIR A VARIAVEL DE RECONSIDERAÇÃO FUTURAMENTE.
if self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_pstc_vclo_apvd'] = 0
self.dicio['vl_slim_21_apvd'] = 0
self.dicio['vl_slim_117_apvd'] = 0
slim_Funci()
def slim_Funci(self):
self.dicio['vl_lim_ref_228'] = self.dicio['vl_lim_ref_140']
self.dicio['vl_mtp_clc_slim_228'] = self.dicio['vl_mtp_clc_slim_140']
self.dicio['vl_ftr_ajst_slim_228'] = self.dicio['vl_ftr_ajst_slim_140']
# Executa o calculo do sublimite calculado e aprovado dos produtos 140, 157, 162, 228
for prd in [140, 157, 162, 228]:
self.processaCalculo(prd)
slim_ecf()
def slim_ecf(self):
self.dicio['vl_mtp_clc_slim_155'] = self.dicio['vl_mtp_clc_slim_137']
self.dicio['vl_lim_ref_155'] = self.dicio['vl_lim_ref_137']
self.dicio['vl_mtp_clc_slim_179'] = self.dicio['vl_mtp_clc_slim_137']
self.dicio['vl_lim_ref_179'] = self.dicio['vl_lim_ref_137']
self.dicio['vl_ftr_ajst_slim_179'] = self.dicio['vl_ftr_ajst_slim_137']
# Calculando o sublimite calculado e aprovado para os produtos 137 e 155
for prd in [137, 155]:
self.processaCalculo(prd)
if self.dicio['vl_slim_155_utzd'] > self.dicio['vl_slim_155_apvd']:
self.dicio['vl_slim_155_apvd'] = self.dicio['vl_slim_155_utzd']
if self.dicio['ic_mtp_cvn_crt'] > 0:
self.processaCalculo(171)
if self.dicio['in_ctr_rsct'] == 1 and self.dicio['in_pttd'] == 'S':
self.dicio['in_ctr_rsct'] = 0
self.dicio['in_ctr_52_18'] = 0
if self.dicio['qt_idd'] > 85 and self.dicio['vl_rend_lqdo_ttl'] < 20000:
pass
else:
if (self.dicio['in_ctr_rsct'] == 1 and self.dicio['cd_prd_rsct'] == 338 and \
self.dicio['cd_mdld_rsct'] == 18) or self.dicio['in_ctra_349'] == 1 or \
self.dicio['in_ctra_349_12'] == 1:
self.dicio['vl_pstc_ecf_clcd'] = self.dicio['vl_pstc_ttl_ecf_org']
self.dicio['vl_pstc_ecf_apvd'] = self.dicio['vl_pstc_ttl_ecf_org']
self.dicio['vl_pstc_fun_bb_clcd'] = self.dicio['vl_pstc_bb_org']
self.dicio['vl_pstc_ecf_demais'] = self.dicio['vl_pstc_demais_org']
if self.dicio['vl_pstc_ecf_rec'] > 0:
if self.dicio['vl_pstc_ecf_rec'] == 0.01:
self.dicio['vl_pstc_ecf_clcd'] = 0
self.dicio['vl_pstc_fun_bb_clcd'] = 0
self.dicio['vl_pstc_ecf_demais'] = 0
else:
self.dicio['vl_pstc_ecf_clcd'] = self.dicio['vl_pstc_ecf_rec']
self.dicio['vl_pstc_fun_bb_clcd'] = self.dicio['vl_pstc_ecf_rec']
self.dicio['vl_pstc_ecf_demais'] = self.dicio['vl_pstc_ecf_rec']
self.processaCalculo(155)
if self.dicio['vl_slim_155_apvd'] == 0:
self.dicio['vl_slim_155_apvd'] = self.dicio['vl_slim_155_utzd']
if self.dicio['vl_slim_137_apvd'] == 0 and self.dicio['vl_slim_171_apvd'] == 0 and \
self.dicio['vl_slim_179_apvd'] == 0:
self.dicio['vl_pstc_ecf_clcd'] = 0
self.dicio['vl_pstc_ecf_apvd'] = 0
self.dicio['vl_pstc_ecf_demais'] = 0
self.dicio['waux_vl_80pc_pstc_ecf_apvd'] = self.dicio['vl_pstc_ecf_apvd'] * 0.80
# INFO: PERTENCE A REGRA DO CMP
#if self.dicio['waux_vl_80pc_pstc_ecf_apvd'] > self.dicio['vl_cmp_apvd']:
# self.dicio['vl_cmp_apvd'] = self.dicio['waux_vl_80pc_pstc_ecf_apvd']
if self.dicio['vl_slim_137_apvd'] > 0:
self.dicio['in_grava_cvn'] += 3
if self.dicio['vl_slim_171_apvd'] > 0:
self.dicio['in_grava_cvn'] += 5
self.processaCalculo(179)
if self.dicio['vl_slim_179_utzd'] > self.dicio['vl_slim_179_apvd']:
self.dicio['vl_slim_179_apvd'] = self.dicio['vl_slim_179_utzd']
slimApvdCdc()
def slimApvdCdc(self):
# Instancias de Classes
#cevs = ClcEstVlSlim(self.dicio)
vrsb = VrfRndSlrBnf(self.dicio)
rms = RedMtpSlim083(self.dicio)
self.dicio['ws_psct_cdc_083_c'] = 0
self.dicio['ws_psct_cdc_115_c'] = 0
if self.dicio['in_518'] == 'S':
if self.dicio['cd_crct_1682'] == 1:
self.dicio['vl_slim_173_apvd'] = 0
else:
# prd = 173
self.processaCalculo(173, 'apvd')
self.dicio['vl_slim_173_apvd'] = int(self.dicio['aux_vl_slim'])
#INCLUIR REGRA DO ANCKCCF1-IN-AUX-EMER AQUI. FALTA INCLUIR A VARIAVEL DE RECONSIDERAÇÃO FUTURAMENTE.
if self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_slim_173_apvd'] = 0
if self.dicio['vl_slim_173_apvd'] == 0 and self.dicio['cd_fuc'] != 2:
if self.dicio['cd_crct_1682'] == 1:
self.dicio['vl_lim_ref_131'] = 0
else:
# prd = 131
self.processaCalculo(131, 'apvd')
#INCLUIR REGRA DO ANCKCCF1-IN-AUX-EMER AQUI. FALTA INCLUIR A VARIAVEL DE RECONSIDERAÇÃO FUTURAMENTE.
if self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_slim_131_apvd'] = 0
self.dicio['vl_slim_130_apvd'] = 0
#INCLUIR REGRA DO ANCKCCF1-IN-AUX-EMER AQUI. FALTA INCLUIR A VARIAVEL DE RECONSIDERAÇÃO FUTURAMENTE.
if self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_slim_130_apvd'] = 0
if self.dicio['cd_crct_1682'] == 1:
self.dicio['vl_slim_116_apvd'] = 0
else:
# prd = 116
self.processaCalculo(116, 'apvd')
#INCLUIR REGRA DO ANCKCCF1-IN-AUX-EMER AQUI. FALTA INCLUIR A VARIAVEL DE RECONSIDERAÇÃO FUTURAMENTE.
if self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_slim_116_apvd'] = 0
vrsb.vrf_Rnd_Slr_Bnf()
if self.dicio['cd_crct_1682'] == 1:
self.dicio['ws_psct_cdc_083_c'] = 0
else:
self.dicio['ws_psct_cdc_083_c'] = (self.dicio['ws_psct_cdc_083_c'] * self.dicio['vl_ftr_ajst_pstc_pcld'])
if self.dicio['vl_pstc_cdc_prtt'] > self.dicio['vl_pstc_cdc_apvd']:
self.dicio['ws_psct_cdc_083_c'] = self.dicio['vl_pstc_cdc_apvd']
else:
self.dicio['ws_psct_cdc_083_c'] = self.dicio['vl_pstc_cdc_prtt']
# Teste incluido pelo Fernando para ajuste na informação do VSAM e valor
if (self.dicio['in_pgt'] and not self.dicio['in_fun'] and self.dicio['ws_psct_cdc_083_c'] > 0) or \
(self.dicio['in_pgt'] and self.dicio['cd_mtdl_anl_crd'] in (70,71,72)):
if self.dicio['ic_mtp_cvn_sal'] != 0:
self.dicio['vl_mtp_clc_slim_83'] = self.dicio['ic_mtp_cvn_sal']
self.dicio['vl_pstc_083'] = self.dicio['ws_psct_cdc_083_c']
# Chama 962000-RED-MTP-SLIM-083
rms.redMtpSlim083()
self.dicio['vl_mtp_clc_slim_83'] = self.dicio['vl_mtp_clc_slim_83'] * \
self.dicio['waux_red_mtp_slim_083']
# Conforme correio DICRE, para clientes sem convenio com FEi
# maior que 0,135335283 , zerar o multiplicador
# Retirado tratamento abaixo conforme ideia 56720
self.processaCalculo(83, 'apvd')
self.dicio['vl_slim_83_apvd'] = int(self.dicio['aux_vl_slim'])
#INCLUIR REGRA DO ANCKCCF1-IN-AUX-EMER AQUI. FALTA INCLUIR A VARIAVEL DE RECONSIDERAÇÃO FUTURAMENTE.
if self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_slim_83_apvd'] = 0
if self.dicio['cd_crct_1682'] == 1:
self.dicio['ws_psct_cdc_115_c'] = 0
else:
self.dicio['ws_psct_cdc_115_c'] = (self.dicio['ws_psct_cdc_115_c'] * self.dicio['vl_ftr_ajst_pstc_pcld'])
if self.dicio['ws_psct_cdc_115_c'] > self.dicio['vl_pstc_cdc_apvd']:
self.dicio['ws_psct_cdc_115_c'] = self.dicio['vl_pstc_cdc_apvd']
# prd = 115
self.processaCalculo(115, 'apvd')
self.dicio['vl_slim_115_apvd'] = int(self.dicio['aux_vl_slim'])
self.dicio['aux_redt_vcli'] = 1
if self.dicio['cd_crct_1682'] == 1:
self.dicio['vl_slim_119_apvd'] = 0
self.dicio['vl_slim_157_apvd'] = 0
self.dicio['vl_slim_156_apvd'] = 0
self.dicio['vl_slim_159_apvd'] = 0
else:
# prd = 119
self.processaCalculo(119, 'apvd')
self.dicio['vl_slim_119_apvd'] = int(self.dicio['aux_vl_slim'])
# prd = 156
self.processaCalculo(156, 'apvd')
self.dicio['vl_slim_156_apvd'] = self.dicio['aux_vl_slim']
# prd = 159
self.processaCalculo(159, 'apvd')
if self.dicio['in_anl_pmt'] == 'S':
self.dicio['vl_slim_159_apvd'] = self.dicio['vl_slim_159_clcd']
else:
self.dicio['vl_slim_159_apvd'] = int(self.dicio['aux_vl_slim'])
# Limitado valor do Credito rotativo
if self.dicio['cd_fuc'] != 2 and self.dicio['cd_crct_1682'] == 0:
if self.dicio['vl_slim_159_apvd'] > self.dicio['vl_slim_15_20_apvd']:
self.dicio['vl_slim_159_apvd'] = self.dicio['vl_slim_15_20_apvd']
#INCLUIR REGRA DO ANCKCCF1-IN-AUX-EMER AQUI. FALTA INCLUIR A VARIAVEL DE RECONSIDERAÇÃO FUTURAMENTE.
if self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_slim_115_apvd'] = 0
self.dicio['vl_slim_119_apvd'] = 0
self.dicio['vl_slim_156_apvd'] = 0
self.dicio['vl_slim_159_apvd'] = 0
self.dicio['vl_slim_157_apvd'] = 0
# prd = 160
self.processaCalculo(160, 'apvd')
self.dicio['vl_slim_160_apvd'] = int(self.dicio['aux_vl_slim'])
self.dicio['aux_redt_vcli'] = 1
if self.dicio['cd_crct_1682'] == 1:
self.dicio['vl_slim_161_apvd'] = 0
self.dicio['vl_slim_163_apvd'] = 0
self.dicio['vl_slim_142_apvd'] = 0
else:
if self.dicio['vl_ren_brto'] <= self.dicio['waux_vl_10slr_min'] and self.dicio['cd_sgm_anl'] in \
(9,19,25,21,30,31,55) and (self.dicio['in_cli_novo'] == 'N' or self.dicio['in_cli_novo_prtt'] == 'S'):
# prd = 161
self.processaCalculo(161, 'apvd')
self.dicio['vl_slim_161_apvd'] = int(self.dicio['aux_vl_slim'])
if self.dicio['vl_slim_161_apvd'] > self.dicio['vl_teto_slim_161']:
self.dicio['vl_slim_161_apvd'] = self.dicio['vl_teto_slim_161']
# prd = 163
self.processaCalculo(163, 'apvd')
self.dicio['vl_slim_163_apvd'] = int(self.dicio['aux_vl_slim'])
if self.dicio['gda_maior_mtp'] > self.dicio['vl_mtp_clc_slim_142']:
self.dicio['vl_mtp_clc_slim_142'] = self.dicio['gda_maior_mtp']
# prd = 142
self.processaCalculo(142, 'apvd')
#INCLUIR REGRA DO ANCKCCF1-IN-AUX-EMER AQUI. FALTA INCLUIR A VARIAVEL DE RECONSIDERAÇÃO FUTURAMENTE.
if self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_slim_142_apvd'] = 0
self.dicio['vl_slim_161_apvd'] = 0
self.dicio['vl_slim_163_apvd'] = 0
if self.dicio['ic_mtp_cvn_sal'] != 0 and self.dicio['ind_grava_cvn'] == 1:
self.dicio['vl_mtp_clc_slim_83'] = self.dicio['ic_mtp_cvn_sal']
slimClcdCdc()
def slimClcdCdc(self):
# Instancias de Classes
# cevs = ClcEstVlSlim(self.dicio)
rms = RedMtpSlim083(self.dicio)
vrsb = VrfRndSlrBnf(self.dicio)
self.dicio['ws_psct_cdc_083_c'] = 0
self.dicio['ws_psct_cdc_115_c'] = 0
self.dicio['aux_far_slim'] = 1
# O código tem como objetivo preparar as variaveis que serão utilizadas para o calculo da prestação calculada
# Regra geral = prestacao * respectivo multiplicador * fator de idade calculado na função 960000
# Prepara as variaveis para todos os sublimites e salva o valor do sublimite calculado após passar pela função 960000
# Preparar a formula (prestacao x fator de idade) -aplicar nos calculos dos sublimites
self.dicio['in_cli_novo'] = 'N'
if (self.dicio['cd_mtdl_anl_crd'] == 52 and self.dicio['cd_sgm_anl'] in (21, 31)) or \
self.dicio['cd_mtdl_anl_crd'] == 53:
self.dicio['in_cli_novo'] = 'S'
# Sublimites 173 (DRS), 130 (benef. 2 sal.) e 131 (pronto) sao excludentes entre si
# BB microcrédito DRS - caracteristica especial 518
if self.dicio['in_518'] == 'S':
self.processaCalculo(173, 'clcd')
# BB credito pronto
if self.dicio['vl_slim_173_clcd'] == 0 and not self.dicio['cd_fuc'] == 2:
self.processaCalculo(131, 'clcd')
# BB credito beneficio 2 salários minimos
self.dicio['vl_slim_130_clcd'] = 0
# CDC automatico
self.processaCalculo(116, 'clcd')
# BB credito salario somente para clientes que recebem pelo BB
# Chama 210000_vrf_rnd_slr_bnf
vrsb.vrf_Rnd_Slr_Bnf()
if self.dicio['vl_pstc_cdc_prtt'] > self.dicio['vl_pstc_cdc_clcd']:
self.dicio['ws_psct_cdc_083_c'] = self.dicio['vl_pstc_cdc_clcd']
else:
self.dicio['ws_psct_cdc_083_c'] = self.dicio['vl_pstc_cdc_prtt']
if (self.dicio['in_pgt'] and not self.dicio['in_fun']) or (self.dicio['in_pgt'] and \
self.dicio['cd_mtdl_anl_crd'] in (70, 71, 72)):
if self.dicio['ic_mtp_cvn_sal'] != 0:
self.dicio['vl_mtp_clc_slim_83'] = self.dicio['ic_mtp_cvn_sal']
self.dicio['vl_pstc_083'] = self.dicio['ws_psct_cdc_083_c']
# d135005_a141024: reduzir o multiplicador de calculo:
self.dicio['aux_cd_cliente'] = self.dicio['cd_cli']
# Chama 962000_red_mtp_slim_083
rms.red_Mtp_Slim_083()
self.dicio['vl_mtp_clc_slim_83'] = self.dicio['vl_mtp_clc_slim_83'] * self.dicio['waux_red_mtp_slim_083']
if self.dicio['vl_pstc_083'] != 0:
self.dicio['ind_grava_cvn'] += 1
# Conforme correio DICRE, para clientes sem convenio com fei maior que 0,135335283, zerar o multiplicador retirado
# tratamento abaixo conforme ideia 56720
if self.dicio['ic_mtp_cvn_sal'] == 0:
if self.dicio['vl_fei_cli'] > 0.135335283:
self.dicio['vl_mtp_clc_slim_83'] = 0
self.processaCalculo(83, 'clcd' )
# Sublimite 115 _ credito beneficio somente para clientes que recebem beneficio pelo BB.
if self.dicio['ws_psct_cdc_115_c'] > self.dicio['vl_pstc_cdc_clcd']:
self.dicio['ws_psct_cdc_115_c'] = self.dicio['vl_pstc_cdc_clcd']
self.processaCalculo(115, 'clcd')
self.processaCalculo(119, 'clcd')
# BB crediario PC conectado
self.processaCalculo(156, 'clcd')
# BB cred p. cartão/cheque
self.processaCalculo(159, 'clcd')
# Limitado valor do credito rotativo
if not self.dicio['cd_fuc'] == 2:
if self.dicio['vl_slim_159_clcd'] > self.dicio['vl_slim_15_20_clcd']:
self.dicio['vl_slim_159_clcd'] = self.dicio['vl_slim_15_20_clcd']
# limite transf p/cartao
self.processaCalculo(160, 'clcd')
# BB credito acessibilidade _ exceto segmentos inss e parcerias
if self.dicio['vl_ren_brto'] < self.dicio['waux_vl_10slr_min'] and \
(self.dicio['cd_sgm_anl'] == 9 or self.dicio['cd_sgm_anl'] in \
(19, 21, 25, 30, 31, 55)) and (self.dicio['in_cli_novo'] == 'N' or \
self.dicio['in_cli_novo_prtt'] == 'S'):
self.processaCalculo(161, 'clcd')
if self.dicio['vl_slim_161_clcd'] > self.dicio['vl_teto_slim_161']:
self.dicio['vl_slim_161_clcd'] = self.dicio['vl_teto_slim_161']
# BB credito parceria
self.processaCalculo(163, 'clcd')
# BB crédito renovação
if self.dicio['gda_maior_mtp'] > self.dicio['vl_mtp_clc_slim_142']:
self.dicio['vl_mtp_clc_slim_142'] = self.dicio['gda_maior_mtp']
self.processaCalculo(142, 'clcd')
trataSnlAlerta()
TrataSnlAlerta()
from parcelado.calculos.calculoFAR import CalculoFar
class TrataSnlAlerta:
def __init__(self, dicio):
self.dicio = dicio
trata_Snl_Alerta()
def trata_Snl_Alerta(self):
# Instancias de Classes
cf = CalculoFar(self.dicio)
# Regra 1 - Sinal de Alerta igual a 0
if self.dicio['cd_snl_avs_pcld'] == 0:
if self.dicio['in_lim_ant'] == 'N':
self.dicio['vl_pstc_ant_045'] = 0
if self.dicio['vl_pstc_ant_045'] > self.dicio['vl_pstc_cdc_clcd']:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['vl_pstc_ant_045']
else:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['vl_pstc_cdc_clcd']
# Chamada para 960000_clc_apvd_com_far
cf.calcularFar('045')
if self.dicio['ws_vl_pstc_far_apvd_045'] > self.dicio['ws_vl_pstc_far_clcd_045']:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['ws_vl_pstc_far_apvd_045']
else:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['ws_vl_pstc_far_clcd_045']
# Regra 2 - Sinal de Alerta igual a 0
elif self.dicio['cd_snl_avs_pcld'] == 1:
if self.dicio['in_lim_ant'] == 'N':
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['vl_pstc_cdc_clcd']
else:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['vl_pstc_ant_045']
# Chamada para 960000_clc_apvd_com_far
cf.calcularFar('045')
if self.dicio['ws_vl_pstc_far_apvd_045'] > self.dicio['ws_vl_pstc_far_clcd_045']:
if self.dicio['ws_vl_pstc_far_apvd_045'] < self.dicio['vl_pstc_cdc_apvd']:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['ws_vl_pstc_far_apvd_045']
else:
if self.dicio['ws_vl_pstc_far_clcd_045'] < self.dicio['vl_pstc_cdc_apvd']:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['ws_vl_pstc_far_clcd_045']
# Regra 3 - Sinal de Alerta igual a 2, 5 e 6
elif self.dicio['cd_snl_avs_pcld'] in (2, 5, 6):
if self.dicio['in_lim_ant'] == 'N':
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['vl_pstc_cdc_clcd']
else:
if self.dicio['vl_pstc_ant_045'] < self.dicio['vl_pstc_cdc_clcd']:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['vl_pstc_ant_045']
else:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['vl_pstc_cdc_clcd']
# Chamada para 960000_clc_apvd_com_far
cf.calcularFar('045')
if self.dicio['ws_vl_pstc_far_apvd_045'] > self.dicio['ws_vl_pstc_far_clcd_045']:
if self.dicio['ws_vl_pstc_far_apvd_045'] < self.dicio['vl_pstc_cdc_apvd']:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['ws_vl_pstc_far_apvd_045']
else:
if self.dicio['ws_vl_pstc_far_clcd_045'] < self.dicio['vl_pstc_cdc_apvd']:
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['ws_vl_pstc_far_clcd_045']
# Regra 4 - Sinal de Alerta igual a 4
elif self.dicio['cd_snl_avs_pcld'] == 4:
self.dicio['vl_pstc_cdc_apvd'] = (self.dicio['vl_pstc_cdc_clcd'] * \
self.dicio['vl_pc_red_pstc_clcd'] * \
self.dicio['vl_ftr_ajst_pstc_pcld'])
trata_Snl_Alerta_Vclo()
def trata_Snl_Alerta_Vclo(self):
# Instancias de Classes
cf = CalculoFar(self.dicio)
if self.dicio['cd_snl_avs_pcld'] == 0:
if self.dicio['in_lim_ant'] == 'N':
self.dicio['vl_pstc_ant_060'] = 0
if self.dicio['vl_ttl_pcl_fin'] > self.dicio['vl_pstc_ant_060']:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['vl_ttl_pcl_fin']
else:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['vl_pstc_ant_060']
if self.dicio['vl_pstc_vclo_apvd'] < self.dicio['vl_pstc_vclo_clcd']:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['vl_pstc_vclo_clcd']
# Chama 950000_clc_apvd_com_far
cf.calcularFar('021')
if self.dicio['ws_vl_pstc_far_apvd_021'] > self.dicio['ws_vl_pstc_far_clcd_021']:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['ws_vl_pstc_far_apvd_021']
else:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['ws_vl_pstc_far_clcd_021']
elif self.dicio['cd_snl_avs_pcld'] == 1:
if self.dicio['vl_ttl_pcl_fin'] > self.dicio['vl_pstc_vclo_clcd']:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['vl_ttl_pcl_fin']
else:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['vl_pstc_vclo_clcd']
if self.dicio['in_lim_ant'] != 'N' and self.dicio['vl_pstc_ant_060'] < \
self.dicio['vl_pstc_vclo_apvd']:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['vl_pstc_ant_060']
# Chama 950000_clc_apvd_com_far
cf.calcularFar('021')
if self.dicio['ws_vl_pstc_far_apvd_021'] > self.dicio['ws_vl_pstc_far_clcd_021']:
if self.dicio['ws_vl_pstc_far_apvd_021'] < self.dicio['vl_pstc_vclo_apvd']:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['ws_vl_pstc_far_apvd_021']
else:
if self.dicio['ws_vl_pstc_far_clcd_021'] < self.dicio['vl_pstc_vclo_apvd']:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['ws_vl_pstc_far_clcd_021']
elif self.dicio['cd_snl_avs_pcld'] in (2, 5, 6):
if self.dicio['in_lim_ant'] == 'N':
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['vl_pstc_vclo_clcd']
else:
if self.dicio['vl_pstc_vclo_clcd'] < self.dicio['vl_pstc_ant_060']:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['vl_pstc_vclo_clcd']
else:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['vl_pstc_ant_060']
#Chama 950000_clc_apvd_com_far
cf.calcularFar('021')
if self.dicio['ws_vl_pstc_far_apvd_021'] > self.dicio['ws_vl_pstc_far_clcd_021']:
if self.dicio['ws_vl_pstc_far_apvd_021'] < self.dicio['vl_pstc_vclo_apvd']:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['ws_vl_pstc_far_apvd_021']
else:
if self.dicio['ws_vl_pstc_far_clcd_021'] < self.dicio['vl_pstc_vclo_apvd']:
self.dicio['vl_pstc_vclo_apvd'] = self.dicio['ws_vl_pstc_far_clcd_021']
elif self.dicio['cd_snl_avs_pcld'] == 4:
self.dicio['vl_pstc_vclo_apvd'] = (self.dicio['vl_pstc_vclo_clcd'] * \
self.dicio['vl_pc_red_pstc_clcd']) * \
self.dicio['vl_ftr_ajst_pstc_vclo']
verifEngajado()
class VerifEngajado:
def __init__(self, dicio):
self.dicio = dicio
self.dicio['waux_engajado'] = 'N'
def verif_Engajado(self, pos):
for i in range(0, self.dicio['qt_reg_epgr_engaj']):
if self.dicio['cd_epgr_engaj'][i] == self.dicio['cd_epgr_cli'][pos]:
self.dicio['waux_engajado'] = 'S'
break
verifGTFraude()
# verifGTFraude
def __init__(self, dicio):
self.dicio = dicio
def verifGTFraude(self):
cpc = CalculoPrtfCdc(self.dicio)
if self.dicio['cd_fuc'] == 1:
if self.dicio['in_frd'] in ('A', 'a'):
if self.dicio['in_pbco_gr_frd']:
if self.dicio['cd_tip_cpvt_ren'] == 'F':
# O código compara o indicador
de relacionamento do cliente para
atribuir valor a variável auxiliar de
percentual de crédito direto ao
consumidor
if self.dicio['in_rlc_cli'] in ('I', 'P', '', ' ', ' '):
self.dicio['waux_pc_cdc'] = 20
# Executa o cálculo do portifólio
de sublimite de CDC
cpc.calcularPrtfCdc()
elif self.dicio['in_rlc_cli'] == 'C':
self.dicio['waux_pc_cdc'] = self.dicio['vl_pc_cdc_rlc_c']
# Executa o cálculo do portifólio de sublimite de CDC
cpc.calcularPrtfCdc()
elif self.dicio['cd_tip_cpvt_ren'] == 'C':
if self.dicio['in_rlc_cli'] in ('I', '', ' ', ' '):
self.dicio['waux_pc_cdc'] = 80
# Executa o cálculo do portifólio de sublimite de CDC
cpc.calcularPrtfCdc()
elif self.dicio['in_rlc_cli'] == 'P':
self.dicio['waux_pc_cdc'] = self.dicio['vl_pc_cdc_rlc_p']
# Executa o cálculo do portifólio de sublimite de CDC
cpc.calcularPrtfCdc()
self.dicio['vl_pstc_vclo_clcd'] = 0
self.dicio['vl_pstc_vclo_apvd'] = 0
vrfRndSlrBnf()
Verifica natureza da ocupação para computar a renda a ser
utilizada no calculo dos sublimites 083 e 115.
from parcelado.regras.verifEngajado import VerifEngajado
import os
class VrfRndSlrBnf():
def __init__(self, dicio):
self.dicio = dicio
self.dicio['gda_epgr_ppl_cli'] = []
def vrf_Rnd_Slr_Bnf(self):
'''
Verifica natureza da ocupacao para computar a renda a ser utilizada no calculo dos
sublimites 083 e 115.
'''
# Instancias de classes
ve = VerifEngajado(self.dicio)
# Declaração de Variaveis
self.dicio['gda_epgr_ppl_cli'] = []
self.dicio['waux_vl_rnd_slr'] = 0
self.dicio['waux_vl_rnd_bnf'] = 0
if os.environ['AMBIENTE'] in ['MODELAGEM', 'DESENVOLVIMENTO']:
self.dicio['waux_mci_inss'] = 103824079
self.dicio['waux_mci_bb'] = 903485186
self.dicio['waux_mci_previ'] = 602907665
elif os.environ['AMBIENTE'] == 'HOMOLOGACAO':
self.dicio['waux_mci_inss'] = 208961759
self.dicio['waux_mci_bb'] = 130965148
self.dicio['waux_mci_previ'] = 178998134
else:
self.dicio['waux_mci_inss'] = 103824079
self.dicio['waux_mci_bb'] = 903485186
self.dicio['waux_mci_previ'] = 100186582
ix1 = 1
for ix in range(0, self.dicio['qt_reg_epgr_cli']):
if self.dicio['cd_ntz'][ix] == 0:
break
if self.dicio['in_ocp_ppl_scdr'][ix] == 'S':
if ix1 < 4:
self.dicio['gda_epgr_ppl_cli'].append(self.dicio['cd_epgr_cli'][ix])
ix1 += 1
# Verifica se cliente novo proventista para cálculo SLIM 161.
self.dicio['in_cli_novo_prtt'] = 'N'
if self.dicio['cd_rgr_rend_lqdo'][ix] == 'C' and self.dicio['in_cli_novo'] == 'S':
self.dicio['in_cli_novo_prtt'] == 'S'
# Verifica se cliente possui renda liquida para GT-FRAUDE
if self.dicio['cd_rgr_rend_lqdo'][ix] == 'C':
self.dicio['in_rlc_cli'] = 'C'
if self.dicio['cd_rgr_rend_lqdo'][ix] == 'C' or self.dicio['vl_bnf'] > 0:
if self.dicio['cd_ntz'][ix] in (2,3,7,10,11,12,14,16,17,18):
pass
elif self.dicio['cd_ntz'][ix] in (19,20):
# Chama 210001-VERIFICA-ENGAJADO
ve.verif_Engajado(ix)
if self.dicio['waux_engajado'] == 'S' and self.dicio['cd_rgr_rend_lqdo'][ix] == 'C':
self.dicio['waux_vl_rnd_slr'] += self.dicio['vl_rend_lqdo'][ix]
else:
if self.dicio['cd_epgr_cli'][ix] == self.dicio['waux_mci_inss'] and \
self.dicio['cd_ntz'][ix] == 8:
self.dicio['waux_vl_rnd_bnf'] += self.dicio['vl_rend_lqdo'][ix]
else:
if self.dicio['cd_rgr_rend_lqdo'][ix] == 'C':
self.dicio['waux_vl_rnd_slr'] += self.dicio['vl_rend_lqdo'][ix]
# Inicio - calcula prestacao com base na renda apurada acima
# ATENÇÃO : Este cálculo está sendo utilizado apenas para produtor rural!
# AVALIAR a implementacao para uso tambem pelo PF (alterar S0160)
for prd in ['083', '115']:
aux = 'slr' if prd == '083' else 'bnf'
self.dicio['ws_pstc_cdc_' + prd + '_c'] = self.dicio['vl_cfct_045'] * \
self.dicio['waux_vl_rnd_' + aux] * \
self.dicio['cd_ftr_rlc'] * \
self.dicio['vl_ftr_demp']
if (self.dicio['in_ctr_rsct'] == 1 and self.dicio['in_ptdd'] == 'N') or \
self.dicio['in_ctra_52_18'] == 1 or self.dicio['in_ctra_349'] == 1 or \
self.dicio['in_ctra_349_12'] == 1:
self.dicio['ws_pstc_cdc_083_c'] = 0
self.dicio['ws_psct_cdc_115_c'] = 0
self.dicio['vl_ren_slr_bnf'] = self.dicio['waux_vl_rnd_slr']
zeraPrestacoes()
zerar()
lass ZeraPrestacoes():
def __init__(self, dicio):
self.dicio = dicio
def zerar(self):
for tipo in ['apvd', 'clcd']:
self.dicio['vl_pstc_cdc_' + tipo ] = 0
zera_Prestacoes()
def zera_Prestacoes(self):
if self.dicio['in_cli_anot_348'] == 'S' and self.dicio['in_cli_adpc_rhbl'] != 1:
self.zerar()
if self.dicio['cd_ntz_ocp'] in (7, 10, 11, 16):
self.zerar()
if self.dicio['in_ctr_rsct'] == 1 and self.dicio['in_ptdd'] == 'N':
self.zerar()
if self.dicio['in_anot'] == 0 and self.dicio['in_ptdd'] == 'S':
self.dicio['in_ctra_52_18'] = 0
if self.dicio['in_ctra_52_18'] == 1 or self.dicio['in_anot'] in (3, 4, 5):
self.zerar()
if self.dicio['in_ctra_349'] == 1 or self.dicio['in_ctra_349_12'] == 1:
self.zerar()
if self.dicio['in_anot'] in (4, 5) and self.dicio['in_ctr_rsct'] == 0:
self.zerar()
if self.dicio['cd_ocp_ppl'] in (179, 200) or self.dicio['cd_cpcd_cvil'] in (2, 3):
if self.dicio['cd_grau_inst'] < 5:
self.zerar()
if self.dicio['cd_mtdl_anl_crd'] == 51 and self.dicio['cd_sgm_anl'] == 19 and self.dicio['in_bco_pstl'] == 'S':
self.zerar()
if self.dicio['cd_tip_bnf'] == 4 and self.dicio['cd_mtdl_anl_crd'] in (52, 53) and self.dicio['in_bco_pstl'] == 'S':
self.zerar()
if self.dicio['qt_idd'] > 85:
self.zerar()
executar()
# Instâncias de Classe e Variáveis
self.dicio = dicio
self.dicio['caminho'] = self.caminho
rpf = RegraPstcEcfFunci(self.dicio)
pp = ProcessaPrestacao(self.dicio)
vf = VerifGTFraude(self.dicio)
ca = CalculoAgrup(self.dicio)
rpc = RegrasPstc(self.dicio)
# cmp = RegraCmp(self.dicio)
ts = TrataSLim(self.dicio)
self.dicio['waux_vl_2slr_min'] = 2 * self.dicio['vl_slr_min']
self.dicio['waux_vl_10slr_min'] = 10 * self.dicio['vl_slr_min']
if self.dicio['vl_slim_15_apvd'] > self.dicio['vl_slim_20_apvd']:
self.dicio['vl_slim_15_20_apvd'] = self.dicio['vl_slim_15_apvd']
else:
self.dicio['vl_slim_15_20_apvd'] = self.dicio['vl_slim_20_apvd']
if self.dicio['vl_slim_15_clcd'] > self.dicio['vl_slim_20_clcd']:
self.dicio['vl_slim_15_20_clcd'] = self.dicio['vl_slim_15_clcd']
else:
self.dicio['vl_slim_15_20_clcd'] = self.dicio['vl_slim_20_clcd']
if self.dicio['cd_fuc'] == 1:
pp.procPrestacao()
rpf.aplicaRegraPstcEcfFunci()
rpc.aplicarRegraPstcVclo()
# cmp.aplicaRegraCMP()
ts.slimClcdCdc()
ts.slimApvdCdc()
# Executa o calculo de grupo para
RAO
ca.calcularGrupos("CDC")
ts.slim_Vclo()
ts.slim_ecf()
# Executa o calculo de grupo para
ECF
ca.calcularGrupos("ECF")
ts.slim_Funci()
# Executa o calculo de grupo para
RAO
ca.calcularGrupos("RAO")
# Executa o calculo de grupo para
Funcionários
ca.calcularGrupos("FUNCI")
# Executa o calculo de grupo para
Veículos
ca.calcularGrupos("VCLO")
# Executa o calculo de grupo para
Rede Externa
ca.calcularGrupos("RDEX")
# Executa o calculo de blocos
ca.calcularBloco()
# Aciona o Verifica GT Fraude
vf.verifGTFraude()
Ancs0160
# ANCS0160
from parcelado.regras.regrasPstc import RegrasPstc
class ANCS0160:
def __init__(self, dicio):
self.dicio = dicio
self.dicio['wgda_teto_pstc_cdc'] = 0
def ancs0160(self):
# Instâncias de Classe
rpc = RegrasPstc(self.dicio)
if self.dicio['cd_status_cli'] != 2:
if self.dicio['cd_status_cli'] == 1 and self.dicio['cd_tip_bnf'] < 4:
if self.dicio['in_anot'] == 4:
self.dicio['in_anot'] = 0
else:
self.dicio['vl_pstc_cdc_clcd'] = 0
self.dicio['vl_pstc_cdc_apvd'] = 0
return
# Cálculo de 40% e 80% da renda
parametrizada
self.dicio['wgda_vl_pc40_rnd_parm_teto'] = self.dicio['vl_ren_prtz_teto'] * 0.40
self.dicio['wgda_vl_pc80_rnd_parm_teto'] = self.dicio['vl_ren_prtz_teto'] * 0.80
# Chamada para 900000-PSTC-CDC-PROVENTISTA
rpc.aplicaRegraPstcProven()
if self.dicio['cd_sgm_anl'] in (9, 19, 21, 25, 30, 31, 39, 55):
# Chamada para calcPstcCorren
rpc.aplicaRegraPstcCorren()
elif self.dicio['cd_sgm_anl'] in (14,
16):
# Chamada para 300000-CALCULO-PSTC-PARC
rpc.aplicaRegraPstcParc()
elif self.dicio['cd_sgm_anl'] == 13:
# Chamada para 200000-CALCULO-PSTC-INSS
rpc.aplicaRegraPstcInss()
ProcPrestacao
ProcessaPrestacao()
# Instância de Classe
c0160 = ANCS0160(self.dicio)
c0160.ancs0160()
if self.dicio['in_anl_pmt'] == 'S':
self.dicio['vl_pstc_cdc_apvd'] = self.dicio['vl_pstc_cdc_clcd']
# Incluir regra do ANCKCCF1-IN-AUX-EMER aqui. Falta incluir a variável de reconsideração futuramente.
f self.dicio['in_bnf_astl'] == 'S' and self.dicio['in_pgt'] == 0:
self.dicio['vl_pstc_cdc_apvd'] = 0
# OBS: NO COBOL ELE ATRIBUI ZERO DUAS VEZES PARA O CDC-APVD