22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194 | class DadgerConfigBuilder:
"""
Builder base para configuração da geração do DADGER.
O SDK usa esta abstração para esconder os cards do `entrada.txt`
e permitir que o consumidor configure a intenção de uso de forma direta.
"""
_RECORD_ORDER = [
RegistroDadger.DP,
RegistroDadger.PQ,
RegistroDadger.RI,
RegistroDadger.IA,
RegistroDadger.VE,
RegistroDadger.CT,
RegistroDadger.MP,
RegistroDadger.FD,
RegistroDadger.TI,
RegistroDadger.RQ,
RegistroDadger.HE,
RegistroDadger.MT,
]
def __init__(self) -> None:
self._gerar_dadger: bool | None = None
self._tipo_geracao_dadger: DadgerGenerationType | None = None
self._parar_apos_gerar_dadger: bool | None = None
self._mes_inicio_dadger_completo: int | None = None
self._ano_inicio_dadger_completo: int | None = None
self._mes_inicio_selecao_dadger: int | None = None
self._ano_inicio_selecao_dadger: int | None = None
self._registros_dadger_modificados: list[RegistroDadger] = []
def enable(
self,
generation_type: DadgerGenerationType | int,
stop_after_generation: bool,
) -> "DadgerConfigBuilder":
self._gerar_dadger = True
self._tipo_geracao_dadger = self._normalize_generation_type(generation_type)
self._parar_apos_gerar_dadger = stop_after_generation
return self
def disable(self) -> "DadgerConfigBuilder":
self._gerar_dadger = False
self._tipo_geracao_dadger = None
self._parar_apos_gerar_dadger = None
self._mes_inicio_dadger_completo = None
self._ano_inicio_dadger_completo = None
self._mes_inicio_selecao_dadger = None
self._ano_inicio_selecao_dadger = None
self._registros_dadger_modificados.clear()
return self
def set_complete_start(self, mes: int, ano: int) -> "DadgerConfigBuilder":
self._mes_inicio_dadger_completo = mes
self._ano_inicio_dadger_completo = ano
return self
def set_selection_start(self, mes: int, ano: int) -> "DadgerConfigBuilder":
self._mes_inicio_selecao_dadger = mes
self._ano_inicio_selecao_dadger = ano
return self
def select_record(self, registro: RegistroDadger | str) -> "DadgerConfigBuilder":
self._registros_dadger_modificados.append(self._normalize_record(registro))
return self
def select_records(
self,
registros: Iterable[RegistroDadger | str],
) -> "DadgerConfigBuilder":
for registro in registros:
self.select_record(registro)
return self
def clear_records(self) -> "DadgerConfigBuilder":
self._registros_dadger_modificados.clear()
return self
def build(self) -> ConfiguracaoDadgerRequest:
if self._gerar_dadger is None:
raise ValueError("É necessário informar se o DADGER deve ser gerado.")
if not self._gerar_dadger:
return ConfiguracaoDadgerRequest(gerarDadger=False)
if self._tipo_geracao_dadger is None:
raise ValueError("generation_type é obrigatório quando o DADGER está habilitado.")
if self._parar_apos_gerar_dadger is None:
raise ValueError("stop_after_generation é obrigatório quando o DADGER está habilitado.")
if self._tipo_geracao_dadger in (
DadgerGenerationType.COMPLETE,
DadgerGenerationType.MIXED,
):
self._validate_month(self._mes_inicio_dadger_completo, "complete_start.month")
self._validate_year(self._ano_inicio_dadger_completo, "complete_start.year")
if self._tipo_geracao_dadger in (
DadgerGenerationType.RECORD_SELECTION,
DadgerGenerationType.MIXED,
):
self._validate_month(self._mes_inicio_selecao_dadger, "selection_start.month")
self._validate_year(self._ano_inicio_selecao_dadger, "selection_start.year")
registros_normalizados = self._normalize_records(self._registros_dadger_modificados)
return ConfiguracaoDadgerRequest(
gerarDadger=True,
tipoGeracaoDadger=int(self._tipo_geracao_dadger),
pararAposGerarDadger=self._parar_apos_gerar_dadger,
mesInicioDadgerCompleto=self._mes_inicio_dadger_completo,
anoInicioDadgerCompleto=self._ano_inicio_dadger_completo,
mesInicioSelecaoDadger=self._mes_inicio_selecao_dadger,
anoInicioSelecaoDadger=self._ano_inicio_selecao_dadger,
registrosDadgerModificados=registros_normalizados,
)
def _normalize_generation_type(
self,
generation_type: DadgerGenerationType | int,
) -> DadgerGenerationType:
try:
return (
generation_type
if isinstance(generation_type, DadgerGenerationType)
else DadgerGenerationType(int(generation_type))
)
except (TypeError, ValueError):
raise ValueError("generation_type deve ser 1, 2 ou 3.")
def _normalize_record(self, registro: RegistroDadger | str) -> RegistroDadger:
if isinstance(registro, RegistroDadger):
return registro
try:
return RegistroDadger(str(registro).strip().upper())
except ValueError:
raise ValueError(f"Registro DADGER inválido: {registro}")
def _normalize_records(
self,
registros: list[RegistroDadger],
) -> list[RegistroDadger]:
duplicates: set[RegistroDadger] = set()
unique_records: set[RegistroDadger] = set()
for registro in registros:
if registro in unique_records:
duplicates.add(registro)
unique_records.add(registro)
if duplicates:
duplicate = sorted(duplicates, key=lambda item: self._RECORD_ORDER.index(item))[0]
raise ValueError(f"Registro DADGER duplicado: {duplicate.value}")
return [registro for registro in self._RECORD_ORDER if registro in unique_records]
def _validate_month(self, month: int | None, field_name: str) -> None:
if month is None:
raise ValueError(f"{field_name} é obrigatório.")
if month < 1 or month > 12:
raise ValueError(f"{field_name} deve estar entre 1 e 12.")
def _validate_year(self, year: int | None, field_name: str) -> None:
if year is None:
raise ValueError(f"{field_name} é obrigatório.")
if year < 1:
raise ValueError(f"{field_name} deve ser maior que zero.")
|