publico/drivers
4
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

merge

Browse source
This commit is contained in:
MarcioJRGodoi 2024-10-28 16:16:01 -03:00
commit 7df1b4fc3d
81 changed files with 2754 additions and 1800 deletions
Download patch file Download diff file Expand all files Collapse all files

56
dist-import/pilao-de-dados/Pilao/index.d.ts vendored Normal file
View file

@ -0,0 +1,56 @@
/** Drive completo do piilão de dados */
import { type tipoResposta } from "p-respostas";
import type { z } from "zod";
import type { zp_enviar_registros } from "../_enviar_registros";
import { type zp_deletar_registros } from "../variaveis";
import type { visoes_pilao } from "../visoes/listaDeVisoes";
import type { tipo_pilao_api } from "./pilao-api.ts";
import type { tipoConstrutorPilao, tipoRetornoSerieconsulta } from "./tipagem";
declare class ClassPilao {
#private;
constructor({ conta, produto, emDesenvolvimento, ver_log, }: tipoConstrutorPilao & {
ver_log?: boolean;
emDesenvolvimento?: boolean;
});
rotaEnviarRegistros(): {
rota: string;
url: string;
};
rotaDeletarRegistro(): {
rota: string;
url: string;
};
rotaConsultarSerie(tipoVisao: keyof typeof visoes_pilao | ":tipoVisao"): {
rota: string;
url: string;
};
rotaIframeSerie(tipoVisao: keyof typeof visoes_pilao | ":tipoVisao"): {
rota: string;
url: string;
};
rotaFuncaoApi(funcao: keyof tipo_pilao_api | ":funcao"): {
rota: string;
url: string;
};
consultarApi<T extends keyof tipo_pilao_api>(funcao: T, parametros: tipo_pilao_api[T]["pr"]): Promise<tipoResposta<tipo_pilao_api[T]["rs"]>>;
get baseUrlApi(): "https://carro-de-boi.idz.one" | "http://localhost:5080";
get baseUrlSite(): "https://carro-de-boi.idz.one" | "http://localhost:5081";
validarCliente(_: any): tipoResposta<tipoConstrutorPilao>;
adicionarRegistroParaEnviar(tabela: string, ...registros: z.infer<typeof zp_enviar_registros>["registros"]): this;
adicionarCodigoParaDeletar(tabela: string, ...codigos: z.infer<typeof zp_deletar_registros>["codigos"]): this;
private processarRegistros;
salvarRegistros(): Promise<tipoResposta<true>>;
serieConsultar<T extends keyof typeof visoes_pilao>(tipoVisao: T, parametros: z.infer<(typeof visoes_pilao)[T]>): {
dados: () => Promise<tipoResposta<tipoRetornoSerieconsulta<T>>>;
url: () => string;
};
urlLaboratorio(): {
rota: string;
url: string;
};
}
export declare const Pilao: (_: tipoConstrutorPilao & {
ver_log?: boolean;
emDesenvolvimento?: boolean;
}) => ClassPilao;
export {};

211
dist-import/pilao-de-dados/Pilao/index.js Normal file
View file

@ -0,0 +1,211 @@
/** Drive completo do piilão de dados */
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _ClassPilao_instances, _ClassPilao_produto, _ClassPilao_conta, _ClassPilao_emDesenvolvimento, _ClassPilao_ver_log, _ClassPilao_registrosParaEnvio, _ClassPilao_codigosParaDeletar, _ClassPilao_gerarUrl, _ClassPilao_salvarEnviarRegistros, _ClassPilao_salvarDeletarRegistros;
import crossFetch from "cross-fetch";
import { nomeVariavel } from "p-comuns";
import { respostaComuns } from "p-respostas";
import { PREFIXO_PILAO } from "../variaveis";
class ClassPilao {
constructor({ conta, produto, emDesenvolvimento = false, ver_log = false, }) {
_ClassPilao_instances.add(this);
_ClassPilao_produto.set(this, void 0);
_ClassPilao_conta.set(this, void 0);
_ClassPilao_emDesenvolvimento.set(this, void 0);
_ClassPilao_ver_log.set(this, void 0);
_ClassPilao_registrosParaEnvio.set(this, {});
_ClassPilao_codigosParaDeletar.set(this, {});
__classPrivateFieldSet(this, _ClassPilao_produto, produto, "f");
__classPrivateFieldSet(this, _ClassPilao_conta, conta, "f");
__classPrivateFieldSet(this, _ClassPilao_emDesenvolvimento, emDesenvolvimento, "f");
__classPrivateFieldSet(this, _ClassPilao_ver_log, ver_log, "f");
}
rotaEnviarRegistros() {
return __classPrivateFieldGet(this, _ClassPilao_instances, "m", _ClassPilao_gerarUrl).call(this, "enviar-registros");
}
rotaDeletarRegistro() {
return __classPrivateFieldGet(this, _ClassPilao_instances, "m", _ClassPilao_gerarUrl).call(this, "deletar-registros");
}
rotaConsultarSerie(tipoVisao) {
return __classPrivateFieldGet(this, _ClassPilao_instances, "m", _ClassPilao_gerarUrl).call(this, "consultar-serie", tipoVisao);
}
rotaIframeSerie(tipoVisao) {
const rota = `${PREFIXO_PILAO}/consultar-serie/${__classPrivateFieldGet(this, _ClassPilao_produto, "f")}/${__classPrivateFieldGet(this, _ClassPilao_conta, "f")}/${tipoVisao}`;
const url = `${this.baseUrlSite}${rota}`;
return { rota, url };
}
rotaFuncaoApi(funcao) {
return __classPrivateFieldGet(this, _ClassPilao_instances, "m", _ClassPilao_gerarUrl).call(this, "API", funcao);
}
async consultarApi(funcao, parametros) {
try {
const response = await crossFetch(this.rotaFuncaoApi(funcao).url, {
body: JSON.stringify(parametros),
method: "POST",
headers: { "Content-Type": "application/json" },
});
const texto = await response.text();
try {
const json = JSON.parse(texto);
return json;
}
catch {
return respostaComuns.erro("Consulta não retornou json válido", [texto]);
}
}
catch (erro) {
console.error(erro);
return respostaComuns.erroInterno({
erro,
local: nomeVariavel({ ClassPilao }),
});
}
}
get baseUrlApi() {
return __classPrivateFieldGet(this, _ClassPilao_emDesenvolvimento, "f")
? "http://localhost:5080"
: "https://carro-de-boi.idz.one";
}
get baseUrlSite() {
return __classPrivateFieldGet(this, _ClassPilao_emDesenvolvimento, "f")
? "http://localhost:5081"
: "https://carro-de-boi.idz.one";
}
validarCliente(_) {
if (!_?.conta)
return respostaComuns.erro("Conta não informada");
if (!_?.produto)
return respostaComuns.erro("Produto não informado");
return respostaComuns.valor(_);
}
adicionarRegistroParaEnviar(tabela, ...registros) {
__classPrivateFieldGet(this, _ClassPilao_registrosParaEnvio, "f")[tabela] = [
...(__classPrivateFieldGet(this, _ClassPilao_registrosParaEnvio, "f")[tabela] || []),
...registros,
];
return this;
}
adicionarCodigoParaDeletar(tabela, ...codigos) {
__classPrivateFieldGet(this, _ClassPilao_codigosParaDeletar, "f")[tabela] = [
...(__classPrivateFieldGet(this, _ClassPilao_codigosParaDeletar, "f")[tabela] || []),
...codigos,
];
return this;
}
async processarRegistros(url, registros, tabela, acao) {
const tamanhoBlocos = 1000;
while (registros.length > 0) {
const bloco = registros
.splice(0, tamanhoBlocos)
.map((r) => Object.fromEntries(Object.entries(r).map(([k, v]) => [k, v === undefined ? null : v])));
const resp = await crossFetch(url, {
method: "POST",
body: JSON.stringify({ tabela, registros: bloco }),
headers: { "Content-Type": "application/json" },
})
.then(async (r) => {
const texto = await r.text();
try {
const json = JSON.parse(texto);
return json;
}
catch {
return respostaComuns.erro("Consulta não retornou json válido", [
texto,
]);
}
})
.catch((e) => respostaComuns.erro(`Erro ao ${acao} registros`, [e.message]));
if (resp.eErro)
return resp;
}
return respostaComuns.valor(true);
}
async salvarRegistros() {
const re = await __classPrivateFieldGet(this, _ClassPilao_instances, "m", _ClassPilao_salvarEnviarRegistros).call(this);
if (re.eErro)
return re;
const rd = await __classPrivateFieldGet(this, _ClassPilao_instances, "m", _ClassPilao_salvarDeletarRegistros).call(this);
if (rd.eErro)
return rd;
return respostaComuns.valor(true);
}
serieConsultar(tipoVisao, parametros) {
const dados = async () => {
const url = this.rotaConsultarSerie(tipoVisao).url;
const resp = await crossFetch(url.toString(), {
method: "POST",
body: JSON.stringify(parametros),
headers: { "Content-Type": "application/json" },
})
.then(async (r) => {
const texto = await r.text();
try {
const json = JSON.parse(texto);
return json;
}
catch {
return respostaComuns.erro("Consulta não retornou json válido", [
texto,
]);
}
})
.catch((e) => respostaComuns.erro("Erro ao enviar registros", [e.message]));
if (__classPrivateFieldGet(this, _ClassPilao_ver_log, "f"))
console.log(`[PILÃO]: buscar dados de "${JSON.stringify(parametros)}" para "${url}".`);
return resp;
};
const url = () => {
const vUrl = this.rotaIframeSerie(tipoVisao).url;
const serie = encodeURIComponent(JSON.stringify(parametros, null, 2));
if (__classPrivateFieldGet(this, _ClassPilao_ver_log, "f"))
console.log(`[PILÃO]: Serie Consultar url de "${JSON.stringify(serie)}" para "${vUrl}".`);
return `${vUrl}?serie=${serie}`;
};
return {
dados,
url,
};
}
urlLaboratorio() {
const rota = `${PREFIXO_PILAO}/laboratório/${__classPrivateFieldGet(this, _ClassPilao_produto, "f")}/${__classPrivateFieldGet(this, _ClassPilao_conta, "f")}`;
const url = `${this.baseUrlSite}${rota}`;
return { rota, url };
}
}
_ClassPilao_produto = new WeakMap(), _ClassPilao_conta = new WeakMap(), _ClassPilao_emDesenvolvimento = new WeakMap(), _ClassPilao_ver_log = new WeakMap(), _ClassPilao_registrosParaEnvio = new WeakMap(), _ClassPilao_codigosParaDeletar = new WeakMap(), _ClassPilao_instances = new WeakSet(), _ClassPilao_gerarUrl = function _ClassPilao_gerarUrl(acao, extraPath) {
const rota = `${PREFIXO_PILAO}/api/${acao}/${__classPrivateFieldGet(this, _ClassPilao_produto, "f")}/${__classPrivateFieldGet(this, _ClassPilao_conta, "f")}${extraPath ? `/${extraPath}` : ""}`;
const url = `${this.baseUrlApi}${rota}`;
return { rota, url };
}, _ClassPilao_salvarEnviarRegistros = async function _ClassPilao_salvarEnviarRegistros() {
for (const tabela of Object.keys(__classPrivateFieldGet(this, _ClassPilao_registrosParaEnvio, "f"))) {
const registros = __classPrivateFieldGet(this, _ClassPilao_registrosParaEnvio, "f")[tabela] || [];
const url = this.rotaEnviarRegistros().url;
if (__classPrivateFieldGet(this, _ClassPilao_ver_log, "f"))
console.log(`[PILÃO]: Enviando ${registros.length} registros na tabela "${tabela}" para "${url}".`);
const resp = await this.processarRegistros(url, registros, tabela, "enviar");
if (resp.eErro)
return resp;
__classPrivateFieldGet(this, _ClassPilao_registrosParaEnvio, "f")[tabela] = [];
}
return respostaComuns.valor(true);
}, _ClassPilao_salvarDeletarRegistros = async function _ClassPilao_salvarDeletarRegistros() {
for (const tabela of Object.keys(__classPrivateFieldGet(this, _ClassPilao_codigosParaDeletar, "f"))) {
const codigos = [...(__classPrivateFieldGet(this, _ClassPilao_codigosParaDeletar, "f")[tabela] || [])];
const url = this.rotaDeletarRegistro().url;
const resp = await this.processarRegistros(url, codigos, tabela, "deletar");
if (resp.eErro)
return resp;
}
return respostaComuns.valor(true);
};
export const Pilao = (_) => new ClassPilao(_);

30
dist-import/pilao-de-dados/Pilao/pilao-api.d.ts vendored Normal file
View file

@ -0,0 +1,30 @@
import type { z } from "zod";
import type { zp_registrar_base_dados } from "../_enviar_registros";
/**
* {
* 'rota':{
* pr:{}// paramentros de entrada
* rs:{}// resposta
* }
* }
*/
export type tipo_pilao_api = {
/** retorna da data e hora do servido em formato iso */
estado_servidor: {
pr: {};
rs: {
data_hora: string;
};
};
tabelas: {
pr: {};
rs: z.infer<typeof zp_registrar_base_dados>[];
};
unicos: {
pr: {
tabela: string;
coluna: string;
};
rs: any[];
};
};

1
dist-import/pilao-de-dados/Pilao/pilao-api.js Normal file
View file

@ -0,0 +1 @@
export {};

11
dist-import/pilao-de-dados/Pilao/tipagem.d.ts vendored Normal file
View file

@ -0,0 +1,11 @@
import type { z } from "zod";
import type { visoes_pilao } from "../visoes/listaDeVisoes";
export type tipoConstrutorPilao = {
produto: string;
conta: string;
};
export type tipoRetornoSerieconsulta<T extends keyof typeof visoes_pilao> = {
registros: any[];
legenda: string;
serie: z.infer<(typeof visoes_pilao)[T]>;
};

1
dist-import/pilao-de-dados/Pilao/tipagem.js Normal file
View file

@ -0,0 +1 @@
export {};

14
dist-import/pilao-de-dados/_deletar_registros.d.ts vendored
View file

@ -1,14 +0,0 @@
import type { tipoResposta } from "p-respostas";
import { z } from "zod";
import { type zp_produto_conta } from "./variaveis";
export declare const zp_deletar_registros: z.ZodObject<{
tabela: z.ZodString;
codigos: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
tabela: string;
codigos: string[];
}, {
tabela: string;
codigos: string[];
}>;
export declare const deletar_registros: ({ conta, produto, emDesenvolvimento }: z.infer<typeof zp_produto_conta>) => ({ codigos: codigos_entrada, tabela, }: z.infer<typeof zp_deletar_registros>) => Promise<tipoResposta<true>>;

29
dist-import/pilao-de-dados/_deletar_registros.js
View file

@ -1,29 +0,0 @@
import node_fetch from "cross-fetch";
import { respostaComuns } from "p-respostas";
import { z } from "zod";
import { urlPilao } from "./variaveis";
//enviar registros para base de dados
export const zp_deletar_registros = z.object({
tabela: z.string(),
codigos: z.array(z.string()),
});
export const deletar_registros = ({ conta, produto, emDesenvolvimento }) => async ({ codigos: codigos_entrada, tabela, }) => {
const codigos = [...codigos_entrada];
const url = new URL(`${urlPilao(emDesenvolvimento).api}/${Object.keys({ deletar_registros })[0]}/${produto}/${conta}`);
const tamanhoBlocos = 1000;
while (codigos.length > 0) {
const bloco = codigos.splice(0, tamanhoBlocos);
const resp = await node_fetch(url.toString(), {
method: "POST",
body: JSON.stringify({ tabela, codigos: bloco }),
headers: { "Content-Type": "application/json" },
})
.then((r) => r.json())
.catch((e) => respostaComuns.erro("Erro ao enviar registros", [e.message]))
.then((r) => r);
if (resp.eErro) {
return resp;
}
}
return respostaComuns.valor(true);
};

3
dist-import/pilao-de-dados/_enviar_registros.d.ts vendored
View file

@ -1,6 +1,4 @@
import type { tipoResposta } from "p-respostas";
import { z } from "zod";
import { type zp_produto_conta } from "./variaveis";
export declare const zp_registrar_base_dados: z.ZodObject<{
tabela: z.ZodString;
colunas: z.ZodArray<z.ZodObject<{
@ -51,4 +49,3 @@ export declare const zp_enviar_registros: z.ZodObject<{
tipo?: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data" | null | undefined;
}>[];
}>;
export declare const enviar_registros: ({ conta, produto, emDesenvolvimento, ver_log, }: z.infer<typeof zp_produto_conta>) => ({ registros: registros_entrada, tabela, }: z.infer<typeof zp_enviar_registros>) => Promise<tipoResposta<true>>;

32
dist-import/pilao-de-dados/_enviar_registros.js
View file

@ -1,12 +1,10 @@
import node_fetch from "cross-fetch";
import { respostaComuns } from "p-respostas";
import { z } from "zod";
import { urlPilao, z_tipo_coluna_base_dados, } from "./variaveis";
import { z_tipos_dados_registro } from "./variaveis";
export const zp_registrar_base_dados = z.object({
tabela: z.string(),
colunas: z.array(z.object({
coluna: z.string(),
tipo: z_tipo_coluna_base_dados,
tipo: z_tipos_dados_registro,
})),
});
//enviar registros para base de dados
@ -14,30 +12,6 @@ export const zp_enviar_registros = z.object({
tabela: z.string(),
registros: z.array(z.record(z.string(), z.object({
valor: z.any(),
tipo: z_tipo_coluna_base_dados.optional().nullable(),
tipo: z_tipos_dados_registro.optional().nullable(),
}))),
});
export const enviar_registros = ({ conta, produto, emDesenvolvimento, ver_log, }) => async ({ registros: registros_entrada, tabela, }) => {
const registros = [...registros_entrada];
const url = new URL(`${urlPilao(emDesenvolvimento).api}/${Object.keys({ enviar_registros })[0]}/${produto}/${conta}`);
if (ver_log)
console.log(`[PILÃO]: Enviando "${registros.length}" registros na tabela "${tabela}" para "${url}".`);
const tamanhoBlocos = 1000;
while (registros.length > 0) {
const bloco = registros
.splice(0, tamanhoBlocos)
.map((r) => Object.fromEntries(Object.entries(r).map(([k, v]) => [k, v === undefined ? null : v])));
const resp = await node_fetch(url.toString(), {
method: "POST",
body: JSON.stringify({ tabela, registros: bloco }),
headers: { "Content-Type": "application/json" },
})
.then((r) => r.json())
.catch((e) => respostaComuns.erro("Erro ao enviar registros", [e.message]))
.then((r) => r);
if (resp.eErro) {
return resp;
}
}
return respostaComuns.valor(true);
};

11
dist-import/pilao-de-dados/_serie_consultar.d.ts vendored
View file

@ -1,7 +1,4 @@
import type { tipoResposta } from "p-respostas";
import { z } from "zod";
import { type zp_produto_conta } from "./variaveis";
import type { visoes } from "./visoes";
export declare const z_filtro: z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
@ -15,11 +12,3 @@ export declare const z_filtro: z.ZodObject<{
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>;
export declare const serie_consultar: (cliente: z.infer<typeof zp_produto_conta>) => <T extends keyof typeof visoes>(tipoVisao: T, parametros: z.infer<(typeof visoes)[T]>) => {
dados: () => Promise<tipoResposta<{
registros: any[];
legenda: string;
serie: z.infer<(typeof visoes)[T]>;
}>>;
url: () => string;
};

31
dist-import/pilao-de-dados/_serie_consultar.js
View file

@ -1,36 +1,7 @@
import node_fetch from "cross-fetch";
import { respostaComuns } from "p-respostas";
import { z } from "zod";
import { operadores_pilao, urlPilao } from "./variaveis";
import { operadores_pilao } from "./variaveis";
export const z_filtro = z.object({
coluna: z.string(),
valor: z.any(),
operador: operadores_pilao,
});
export const serie_consultar = (cliente) => (tipoVisao, parametros) => {
const dados = async () => {
const url = new URL(`${urlPilao(cliente.emDesenvolvimento).api}/${tipoVisao}/${cliente.produto}/${cliente.conta}`);
const resp = await node_fetch(url.toString(), {
method: "POST",
body: JSON.stringify(parametros),
headers: { "Content-Type": "application/json" },
})
.then((r) => r.json())
.catch((e) => respostaComuns.erro("Erro ao enviar registros", [e.message]))
.then((r) => r);
if (cliente.ver_log)
console.log(`[PILÃO]: buscar dados de "${JSON.stringify(parametros)}" para "${url.href}".`);
return resp;
};
const url = () => {
const vUrl = new URL(`${urlPilao(cliente.emDesenvolvimento).site}/${tipoVisao}/${cliente.produto}/${cliente.conta}`);
const serie = encodeURIComponent(JSON.stringify(parametros, null, 2));
if (cliente.ver_log)
console.log(`[PILÃO]: Serie Consultar url de "${JSON.stringify(serie)}" para "${vUrl.href}".`);
return `${vUrl.href}?serie=${serie}`;
};
return {
dados,
url,
};
};

293
dist-import/pilao-de-dados/index.d.ts vendored
View file

@ -1,169 +1,13 @@
import { zp_deletar_registros } from "./_deletar_registros";
export { PREFIXO_PILAO, urlPilao } from "./variaveis";
import { zp_enviar_registros } from "./_enviar_registros";
import { zp_produto_conta } from "./variaveis";
import { visoes } from "./visoes";
export * from "./Pilao";
export * from "./Pilao/pilao-api";
export * from "./Pilao/tipagem";
export declare const pPilao: {
extruturas_de_campos: {
z_contagem_em_barra_vertical: {
visao: "z_contagem_em_barra_vertical";
rotulo: string;
tabela: (_: {
tabela: string;
colanuEixoX: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}) => string;
descricao: (_: {
tabela: string;
colanuEixoX: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}) => string;
campos: {
tabela: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
colanuEixoX: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
colunaAgrupamento: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
filtros: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
descricao_pelo_usuario: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
};
};
z_contagem_em_pizza: {
visao: "z_contagem_em_pizza";
rotulo: string;
tabela: (_: {
tabela: string;
classes: string;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}) => string;
descricao: (_: {
tabela: string;
classes: string;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}) => string;
campos: {
tabela: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
classes: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
filtros: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
descricao_pelo_usuario: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
};
};
z_tabela: {
visao: "z_tabela";
rotulo: string;
tabela: (_: {
tabela: string;
colunas: string[];
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
coluna_ordem?: string | undefined;
direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
}) => string;
descricao: (_: {
tabela: string;
colunas: string[];
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
coluna_ordem?: string | undefined;
direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
}) => string;
campos: {
tabela: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
colunas: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
filtros: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
descricao_pelo_usuario: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
coluna_ordem: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
direcao_ordem: {
rotulo: string;
tipo_campo: import("zod").TypeOf<import("zod").ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>>;
order: number;
};
};
};
z_contagem_em_barra_vertical: import("./visoes/tipagem").tipo_estrutura_visao_grafico<"z_contagem_em_barra_vertical">;
z_contagem_em_pizza: import("./visoes/tipagem").tipo_estrutura_visao_grafico<"z_contagem_em_pizza">;
z_tabela: import("./visoes/tipagem").tipo_estrutura_visao_grafico<"z_tabela">;
z_soma_em_barra_vertical: import("./visoes/tipagem").tipo_estrutura_visao_grafico<"z_soma_em_barra_vertical">;
};
z_contagem_em_barra_vertical: import("zod").ZodObject<{
tabela: import("zod").ZodString;
@ -282,6 +126,61 @@ export declare const pPilao: {
coluna_ordem?: string | undefined;
direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
}>;
z_soma_em_barra_vertical: import("zod").ZodObject<{
tabela: import("zod").ZodString;
colanuEixoX: import("zod").ZodString;
colunaSoma: import("zod").ZodString;
unidadeSoma: import("zod").ZodOptional<import("zod").ZodString>;
colunaAgrupamento: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
filtros: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
coluna: import("zod").ZodString;
valor: import("zod").ZodAny;
operador: import("zod").ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", import("zod").ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: import("zod").ZodOptional<import("zod").ZodString>;
}, "strip", import("zod").ZodTypeAny, {
tabela: string;
colanuEixoX: string;
colunaSoma: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
unidadeSoma?: string | undefined;
}, {
tabela: string;
colanuEixoX: string;
colunaSoma: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
unidadeSoma?: string | undefined;
}>;
zp_deletar_registros: import("zod").ZodObject<{
tabela: import("zod").ZodString;
codigos: import("zod").ZodArray<import("zod").ZodString, "many">;
}, "strip", import("zod").ZodTypeAny, {
tabela: string;
codigos: string[];
}, {
tabela: string;
codigos: string[];
}>;
zp_registrar_base_dados: import("zod").ZodObject<{
tabela: import("zod").ZodString;
colunas: import("zod").ZodArray<import("zod").ZodObject<{
@ -307,7 +206,7 @@ export declare const pPilao: {
tipo: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data";
}[];
}>;
enviar_registros: ({ conta, produto, emDesenvolvimento, ver_log, }: import("zod").TypeOf<typeof zp_produto_conta>) => ({ registros: registros_entrada, tabela, }: import("zod").TypeOf<typeof zp_enviar_registros>) => Promise<import("p-respostas").tipoResposta<true>>;
z_tipos_dados_registro: import("zod").ZodEnum<["texto", "numero", "confirmacao", "lista_texto", "lista_numero", "lista_mes", "lista_data", "mes", "data"]>;
zp_enviar_registros: import("zod").ZodObject<{
tabela: import("zod").ZodString;
registros: import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@ -333,14 +232,6 @@ export declare const pPilao: {
tipo?: "texto" | "numero" | "confirmacao" | "lista_texto" | "lista_numero" | "lista_mes" | "lista_data" | "mes" | "data" | null | undefined;
}>[];
}>;
serie_consultar: (cliente: import("zod").TypeOf<typeof zp_produto_conta>) => <T extends keyof typeof visoes>(tipoVisao: T, parametros: import("zod").TypeOf<(typeof visoes)[T]>) => {
dados: () => Promise<import("p-respostas").tipoResposta<{
registros: any[];
legenda: string;
serie: import("zod").TypeOf<(typeof visoes)[T]>;
}>>;
url: () => string;
};
zp_produto_conta: import("zod").ZodObject<{
produto: import("zod").ZodString;
conta: import("zod").ZodString;
@ -358,17 +249,6 @@ export declare const pPilao: {
ver_log?: boolean | undefined;
}>;
validarZ: <T>(zodType: import("zod").ZodType<T, any>, objeto: any, mensagem: string) => import("p-respostas").tipoRespostaErro | import("p-respostas").tipoRespostaSucesso<T>;
deletar_registros: ({ conta, produto, emDesenvolvimento }: import("zod").TypeOf<typeof zp_produto_conta>) => ({ codigos: codigos_entrada, tabela, }: import("zod").TypeOf<typeof zp_deletar_registros>) => Promise<import("p-respostas").tipoResposta<true>>;
zp_deletar_registros: import("zod").ZodObject<{
tabela: import("zod").ZodString;
codigos: import("zod").ZodArray<import("zod").ZodString, "many">;
}, "strip", import("zod").ZodTypeAny, {
tabela: string;
codigos: string[];
}, {
tabela: string;
codigos: string[];
}>;
operadores_pilao: import("zod").ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
operadores_permitidos_por_tipo: {
texto: ("=" | "!=" | ">" | "<" | ">=" | "<=" | "∩")[];
@ -394,7 +274,7 @@ export declare const pPilao: {
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>;
visoes: {
visoes_pilao: {
z_contagem_em_barra_vertical: import("zod").ZodObject<{
tabela: import("zod").ZodString;
colanuEixoX: import("zod").ZodString;
@ -512,5 +392,50 @@ export declare const pPilao: {
coluna_ordem?: string | undefined;
direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
}>;
z_soma_em_barra_vertical: import("zod").ZodObject<{
tabela: import("zod").ZodString;
colanuEixoX: import("zod").ZodString;
colunaSoma: import("zod").ZodString;
unidadeSoma: import("zod").ZodOptional<import("zod").ZodString>;
colunaAgrupamento: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
filtros: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
coluna: import("zod").ZodString;
valor: import("zod").ZodAny;
operador: import("zod").ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", import("zod").ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: import("zod").ZodOptional<import("zod").ZodString>;
}, "strip", import("zod").ZodTypeAny, {
tabela: string;
colanuEixoX: string;
colunaSoma: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
unidadeSoma?: string | undefined;
}, {
tabela: string;
colanuEixoX: string;
colunaSoma: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
unidadeSoma?: string | undefined;
}>;
};
};

23
dist-import/pilao-de-dados/index.js
View file

@ -1,22 +1,23 @@
import { deletar_registros, zp_deletar_registros } from "./_deletar_registros";
export { PREFIXO_PILAO, urlPilao } from "./variaveis";
import { enviar_registros, zp_enviar_registros, zp_registrar_base_dados, } from "./_enviar_registros";
import { operadores_permitidos_por_tipo, operadores_pilao, validarZ, zp_produto_conta, } from "./variaveis";
import { serie_consultar, z_filtro } from "./_serie_consultar";
import { extruturas_de_campos, visoes } from "./visoes";
import { zp_enviar_registros, zp_registrar_base_dados, } from "./_enviar_registros";
import { operadores_permitidos_por_tipo, operadores_pilao, validarZ, z_tipos_dados_registro, zp_deletar_registros, zp_produto_conta, } from "./variaveis";
export * from "./Pilao";
export * from "./Pilao/pilao-api";
export * from "./Pilao/tipagem";
import { z_filtro } from "./_serie_consultar";
import { extruturas_de_campos } from "./visoes";
import { visoes_pilao } from "./visoes/listaDeVisoes";
export const pPilao = {
zp_deletar_registros,
zp_registrar_base_dados,
enviar_registros,
z_tipos_dados_registro,
zp_enviar_registros,
serie_consultar,
zp_produto_conta,
validarZ,
deletar_registros,
zp_deletar_registros,
operadores_pilao,
operadores_permitidos_por_tipo,
z_filtro,
visoes,
...visoes,
visoes_pilao,
...visoes_pilao,
extruturas_de_campos,
};

14
dist-import/pilao-de-dados/variaveis.d.ts vendored
View file

@ -1,4 +1,14 @@
import { z } from "zod";
export declare const zp_deletar_registros: z.ZodObject<{
tabela: z.ZodString;
codigos: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
tabela: string;
codigos: string[];
}, {
tabela: string;
codigos: string[];
}>;
export declare const zAmbiente: z.ZodEnum<["desenvolvimento", "producao"]>;
export declare const PREFIXO_PILAO = "/pilao-de-dados";
export declare const validarZ: <T>(zodType: z.ZodType<T, any>, objeto: any, mensagem: string) => import("p-respostas").tipoRespostaErro | import("p-respostas").tipoRespostaSucesso<T>;
@ -18,10 +28,10 @@ export declare const zp_produto_conta: z.ZodObject<{
emDesenvolvimento?: boolean | undefined;
ver_log?: boolean | undefined;
}>;
export declare const z_tipo_coluna_base_dados: z.ZodEnum<["texto", "numero", "confirmacao", "lista_texto", "lista_numero", "lista_mes", "lista_data", "mes", "data"]>;
export declare const z_tipos_dados_registro: z.ZodEnum<["texto", "numero", "confirmacao", "lista_texto", "lista_numero", "lista_mes", "lista_data", "mes", "data"]>;
export declare const operadores_pilao: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
export declare const operadores_permitidos_por_tipo: {
[key in z.infer<typeof z_tipo_coluna_base_dados>]: z.infer<typeof operadores_pilao>[];
[key in z.infer<typeof z_tipos_dados_registro>]: z.infer<typeof operadores_pilao>[];
};
export declare const z_validar_colunna_base_dados: {
texto: z.ZodNullable<z.ZodString>;

6
dist-import/pilao-de-dados/variaveis.js
View file

@ -1,5 +1,9 @@
import { respostaComuns } from "p-respostas";
import { z } from "zod";
export const zp_deletar_registros = z.object({
tabela: z.string(),
codigos: z.array(z.string()),
});
export const zAmbiente = z.enum(["desenvolvimento", "producao"]);
export const PREFIXO_PILAO = "/pilao-de-dados";
export const validarZ = (zodType, objeto, mensagem) => {
@ -15,7 +19,7 @@ export const zp_produto_conta = z.object({
emDesenvolvimento: z.boolean().optional(),
ver_log: z.boolean().optional(),
});
export const z_tipo_coluna_base_dados = z.enum([
export const z_tipos_dados_registro = z.enum([
"texto",
"numero",
"confirmacao",

6
dist-import/pilao-de-dados/visoes/estrutura_de_campos/index.d.ts vendored Normal file
View file

@ -0,0 +1,6 @@
import type { visoes_pilao } from "../listaDeVisoes";
import type { tipo_estrutura_visao_grafico } from "../tipagem";
/** Cria a estrutura de campos para insersão de dados */
export declare const extruturas_de_campos: {
[T in keyof typeof visoes_pilao]: tipo_estrutura_visao_grafico<T>;
};

11
dist-import/pilao-de-dados/visoes/estrutura_de_campos/index.js Normal file
View file

@ -0,0 +1,11 @@
import { z_contagem_em_barra_vertical } from "./z_contagem_em_barra_vertical";
import { z_contagem_em_pizza } from "./z_contagem_em_pizza";
import { z_soma_em_barra_vertical } from "./z_soma_em_barra_vertical";
import { z_tabela } from "./z_tabela";
/** Cria a estrutura de campos para insersão de dados */
export const extruturas_de_campos = {
z_contagem_em_barra_vertical,
z_contagem_em_pizza,
z_soma_em_barra_vertical,
z_tabela,
};

3
dist-import/pilao-de-dados/visoes/estrutura_de_campos/z_contagem_em_barra_vertical.d.ts vendored Normal file
View file

@ -0,0 +1,3 @@
import type { tipo_estrutura_visao_grafico } from "../tipagem";
/** Cria a estrutura de campos para insersão de dados */
export declare const z_contagem_em_barra_vertical: tipo_estrutura_visao_grafico<"z_contagem_em_barra_vertical">;

37
dist-import/pilao-de-dados/visoes/estrutura_de_campos/z_contagem_em_barra_vertical.js Normal file
View file

@ -0,0 +1,37 @@
// usar describe para definir o tipo de campo para render do componente
/** Cria a estrutura de campos para insersão de dados */
export const z_contagem_em_barra_vertical = {
visao: "z_contagem_em_barra_vertical",
rotulo: "Contagem em Barra Vertical",
tabela: ({ tabela }) => tabela,
descricao: ({ tabela, descricao_pelo_usuario, colanuEixoX, filtros, colunaAgrupamento, }) => {
if (String(descricao_pelo_usuario || "").trim())
return String(descricao_pelo_usuario || "").trim();
return `Contagem de ${tabela} por ${colanuEixoX}${!filtros?.length
? ""
: `, quando ${filtros
.map(({ coluna, operador, valor }) => `${coluna} ${operador} ${valor}`)
.join(", ")}`}${!colunaAgrupamento?.length
? ""
: `, agrupado por ${colunaAgrupamento.join(", ")}`}.`;
},
campos: {
tabela: { rotulo: "Tabela", tipo_campo: "tabela", order: 1 },
colanuEixoX: {
rotulo: "Coluna do Eixo X",
tipo_campo: "coluna",
order: 2,
},
colunaAgrupamento: {
rotulo: "Colunas de Agrupamento",
tipo_campo: "lista_colunas",
order: 3,
},
descricao_pelo_usuario: {
rotulo: "Descrição (opcional)",
tipo_campo: "texto",
order: 4,
},
filtros: { rotulo: "Filtros", tipo_campo: "lista_filtros", order: 5 },
},
};

3
dist-import/pilao-de-dados/visoes/estrutura_de_campos/z_contagem_em_pizza.d.ts vendored Normal file
View file

@ -0,0 +1,3 @@
import type { tipo_estrutura_visao_grafico } from "../tipagem";
/** Cria a estrutura de campos para insersão de dados */
export declare const z_contagem_em_pizza: tipo_estrutura_visao_grafico<"z_contagem_em_pizza">;

26
dist-import/pilao-de-dados/visoes/estrutura_de_campos/z_contagem_em_pizza.js Normal file
View file

@ -0,0 +1,26 @@
// usar describe para definir o tipo de campo para render do componente
/** Cria a estrutura de campos para insersão de dados */
export const z_contagem_em_pizza = {
visao: "z_contagem_em_pizza",
rotulo: "Contagem em Pizza",
tabela: ({ tabela }) => tabela,
descricao: ({ tabela, descricao_pelo_usuario, classes, filtros }) => {
if (String(descricao_pelo_usuario || "").trim())
return String(descricao_pelo_usuario || "").trim();
return `Contagem de ${tabela} por ${classes}${!filtros?.length
? ""
: `, quando ${filtros
.map(({ coluna, operador, valor }) => `${coluna} ${operador} ${valor}`)
.join(", ")}`}.`;
},
campos: {
tabela: { rotulo: "Tabela", tipo_campo: "tabela", order: 1 },
classes: { rotulo: "Classes", tipo_campo: "coluna", order: 2 },
descricao_pelo_usuario: {
rotulo: "Descrição (opcional)",
tipo_campo: "texto",
order: 3,
},
filtros: { rotulo: "Filtros", tipo_campo: "lista_filtros", order: 4 },
},
};

3
dist-import/pilao-de-dados/visoes/estrutura_de_campos/z_soma_em_barra_vertical.d.ts vendored Normal file
View file

@ -0,0 +1,3 @@
import type { tipo_estrutura_visao_grafico } from "../tipagem";
/** Cria a estrutura de campos para insersão de dados */
export declare const z_soma_em_barra_vertical: tipo_estrutura_visao_grafico<"z_soma_em_barra_vertical">;

47
dist-import/pilao-de-dados/visoes/estrutura_de_campos/z_soma_em_barra_vertical.js Normal file
View file

@ -0,0 +1,47 @@
// usar describe para definir o tipo de campo para render do componente
/** Cria a estrutura de campos para insersão de dados */
export const z_soma_em_barra_vertical = {
visao: "z_soma_em_barra_vertical",
rotulo: "Soma em Barra Vertical",
tabela: ({ tabela }) => tabela,
descricao: ({ descricao_pelo_usuario, colanuEixoX, filtros, colunaAgrupamento, colunaSoma, }) => {
if (String(descricao_pelo_usuario || "").trim())
return String(descricao_pelo_usuario || "").trim();
return `Soma de ${colunaSoma} por ${colanuEixoX}${!filtros?.length
? ""
: `, quando ${filtros
.map(({ coluna, operador, valor }) => `${coluna} ${operador} ${valor}`)
.join(", ")}`}${!colunaAgrupamento?.length
? ""
: `, agrupado por ${colunaAgrupamento.join(", ")}`}.`;
},
campos: {
tabela: { rotulo: "Tabela", tipo_campo: "tabela", order: 1 },
colunaSoma: {
rotulo: "Coluna de Somatória",
tipo_campo: "coluna",
order: 2,
},
unidadeSoma: {
rotulo: "Unidade de Somatória",
tipo_campo: "texto",
order: 3,
},
colanuEixoX: {
rotulo: "Coluna do Eixo X",
tipo_campo: "coluna",
order: 4,
},
colunaAgrupamento: {
rotulo: "Colunas de Agrupamento",
tipo_campo: "lista_colunas",
order: 5,
},
descricao_pelo_usuario: {
rotulo: "Descrição (opcional)",
tipo_campo: "texto",
order: 6,
},
filtros: { rotulo: "Filtros", tipo_campo: "lista_filtros", order: 5 },
},
};

3
dist-import/pilao-de-dados/visoes/estrutura_de_campos/z_tabela.d.ts vendored Normal file
View file

@ -0,0 +1,3 @@
import type { tipo_estrutura_visao_grafico } from "../tipagem";
/** Cria a estrutura de campos para insersão de dados */
export declare const z_tabela: tipo_estrutura_visao_grafico<"z_tabela">;

36
dist-import/pilao-de-dados/visoes/estrutura_de_campos/z_tabela.js Normal file
View file

@ -0,0 +1,36 @@
// usar describe para definir o tipo de campo para render do componente
/** Cria a estrutura de campos para insersão de dados */
export const z_tabela = {
visao: "z_tabela",
rotulo: "Tabela",
tabela: ({ tabela }) => tabela,
descricao: ({ tabela, descricao_pelo_usuario, filtros }) => {
if (String(descricao_pelo_usuario || "").trim())
return String(descricao_pelo_usuario || "").trim();
return `Consulta na ${tabela} ${!filtros?.length
? ""
: `, quando ${filtros
.map(({ coluna, operador, valor }) => `${coluna} ${operador} ${valor}`)
.join(", ")}`}.`;
},
campos: {
tabela: { rotulo: "Tabela", tipo_campo: "tabela", order: 1 },
colunas: { rotulo: "Colunas", tipo_campo: "lista_colunas", order: 2 },
descricao_pelo_usuario: {
rotulo: "Descrição (opcional)",
tipo_campo: "texto",
order: 3,
},
coluna_ordem: {
rotulo: "Coluna de Ordem",
tipo_campo: "coluna",
order: 4,
},
direcao_ordem: {
rotulo: "Direção de Ordem",
tipo_campo: "ordem",
order: 5,
},
filtros: { rotulo: "Filtros", tipo_campo: "lista_filtros", order: 6 },
},
};

261
dist-import/pilao-de-dados/visoes/index.d.ts vendored
View file

@ -1,260 +1 @@
import { z } from "zod";
declare const z_tipos_campos: z.ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>;
export declare const z_contagem_em_barra_vertical: z.ZodObject<{
tabela: z.ZodString;
colanuEixoX: z.ZodString;
colunaAgrupamento: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
colanuEixoX: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}, {
tabela: string;
colanuEixoX: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}>;
export declare const z_contagem_em_pizza: z.ZodObject<{
tabela: z.ZodString;
classes: z.ZodString;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
classes: string;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}, {
tabela: string;
classes: string;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}>;
export declare const z_tabela: z.ZodObject<{
tabela: z.ZodString;
colunas: z.ZodArray<z.ZodString, "many">;
coluna_ordem: z.ZodOptional<z.ZodString>;
direcao_ordem: z.ZodOptional<z.ZodEnum<["asc", "desc", "1", "-1"]>>;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
colunas: string[];
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
coluna_ordem?: string | undefined;
direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
}, {
tabela: string;
colunas: string[];
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
coluna_ordem?: string | undefined;
direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
}>;
export declare const visoes: {
z_contagem_em_barra_vertical: z.ZodObject<{
tabela: z.ZodString;
colanuEixoX: z.ZodString;
colunaAgrupamento: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
colanuEixoX: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}, {
tabela: string;
colanuEixoX: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}>;
z_contagem_em_pizza: z.ZodObject<{
tabela: z.ZodString;
classes: z.ZodString;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
classes: string;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}, {
tabela: string;
classes: string;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}>;
z_tabela: z.ZodObject<{
tabela: z.ZodString;
colunas: z.ZodArray<z.ZodString, "many">;
coluna_ordem: z.ZodOptional<z.ZodString>;
direcao_ordem: z.ZodOptional<z.ZodEnum<["asc", "desc", "1", "-1"]>>;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
colunas: string[];
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
coluna_ordem?: string | undefined;
direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
}, {
tabela: string;
colunas: string[];
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
coluna_ordem?: string | undefined;
direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
}>;
};
/** Cria a estrutura de campos para insersão de dados */
export declare const extruturas_de_campos: {
[z in keyof typeof visoes]: {
/** Nome da Visão */
visao: z;
/** Rotulo */
rotulo: string;
/** Retorna a tabela Referente ao Registro */
tabela: (_: z.infer<(typeof visoes)[z]>) => string;
/** Descrição */
descricao: (_: z.infer<(typeof visoes)[z]>) => string;
/** Lista os campos e suas configurações */
campos: {
[c in keyof Required<z.infer<(typeof visoes)[z]>>]: {
rotulo: string;
tipo_campo: z.infer<typeof z_tipos_campos>;
order: number;
};
};
};
};
export {};
export * from "./estrutura_de_campos";

134
dist-import/pilao-de-dados/visoes/index.js
View file

@ -1,133 +1 @@
import { z } from "zod";
import { z_filtro } from "../_serie_consultar";
// usar describe para definir o tipo de campo para render do componente
const z_tipos_campos = z.enum([
"tabela",
"coluna",
"texto",
"lista_colunas",
"lista_filtros",
"ordem",
]);
export const z_contagem_em_barra_vertical = z.object({
tabela: z.string(),
colanuEixoX: z.string(),
colunaAgrupamento: z.string().array().optional(),
filtros: z_filtro.array().optional(),
descricao_pelo_usuario: z.string().optional(),
});
export const z_contagem_em_pizza = z.object({
tabela: z.string(),
classes: z.string(),
filtros: z_filtro.array().optional(),
descricao_pelo_usuario: z.string().optional(),
});
export const z_tabela = z.object({
tabela: z.string(),
colunas: z.string().array(),
coluna_ordem: z.string().optional(),
direcao_ordem: z.enum(["asc", "desc", "1", "-1"]).optional(),
filtros: z_filtro.array().optional(),
descricao_pelo_usuario: z.string().optional(),
});
export const visoes = {
z_contagem_em_barra_vertical,
z_contagem_em_pizza,
z_tabela,
};
/** Cria a estrutura de campos para insersão de dados */
export const extruturas_de_campos = {
z_contagem_em_barra_vertical: {
visao: "z_contagem_em_barra_vertical",
rotulo: "Contagem em Barra Vertical",
tabela: ({ tabela }) => tabela,
descricao: ({ tabela, descricao_pelo_usuario, colanuEixoX, filtros, colunaAgrupamento, }) => {
if (String(descricao_pelo_usuario || "").trim())
return String(descricao_pelo_usuario || "").trim();
return `Contagem de ${tabela} por ${colanuEixoX}${!filtros?.length
? ""
: `, quando ${filtros
.map(({ coluna, operador, valor }) => `${coluna} ${operador} ${valor}`)
.join(", ")}`}${!colunaAgrupamento?.length
? ""
: `, agrupado por ${colunaAgrupamento.join(", ")}`}.`;
},
campos: {
tabela: { rotulo: "Tabela", tipo_campo: "tabela", order: 1 },
colanuEixoX: {
rotulo: "Coluna do Eixo X",
tipo_campo: "coluna",
order: 2,
},
colunaAgrupamento: {
rotulo: "Colunas de Agrupamento",
tipo_campo: "lista_colunas",
order: 3,
},
descricao_pelo_usuario: {
rotulo: "Descrição (opcional)",
tipo_campo: "texto",
order: 4,
},
filtros: { rotulo: "Filtros", tipo_campo: "lista_filtros", order: 5 },
},
},
z_contagem_em_pizza: {
visao: "z_contagem_em_pizza",
rotulo: "Contagem em Pizza",
tabela: ({ tabela }) => tabela,
descricao: ({ tabela, descricao_pelo_usuario, classes, filtros }) => {
if (String(descricao_pelo_usuario || "").trim())
return String(descricao_pelo_usuario || "").trim();
return `Contagem de ${tabela} por ${classes}${!filtros?.length
? ""
: `, quando ${filtros
.map(({ coluna, operador, valor }) => `${coluna} ${operador} ${valor}`)
.join(", ")}`}.`;
},
campos: {
tabela: { rotulo: "Tabela", tipo_campo: "tabela", order: 1 },
classes: { rotulo: "Classes", tipo_campo: "coluna", order: 2 },
descricao_pelo_usuario: {
rotulo: "Descrição (opcional)",
tipo_campo: "texto",
order: 3,
},
filtros: { rotulo: "Filtros", tipo_campo: "lista_filtros", order: 4 },
},
},
z_tabela: {
visao: "z_tabela",
rotulo: "Tabela",
tabela: ({ tabela }) => tabela,
descricao: ({ tabela, descricao_pelo_usuario, filtros }) => {
if (String(descricao_pelo_usuario || "").trim())
return String(descricao_pelo_usuario || "").trim();
return `Consulta na ${tabela} ${!filtros?.length
? ""
: `, quando ${filtros
.map(({ coluna, operador, valor }) => `${coluna} ${operador} ${valor}`)
.join(", ")}`}.`;
},
campos: {
tabela: { rotulo: "Tabela", tipo_campo: "tabela", order: 1 },
colunas: { rotulo: "Colunas", tipo_campo: "lista_colunas", order: 2 },
descricao_pelo_usuario: {
rotulo: "Descrição (opcional)",
tipo_campo: "texto",
order: 3,
},
coluna_ordem: {
rotulo: "Coluna de Ordem",
tipo_campo: "coluna",
order: 4,
},
direcao_ordem: {
rotulo: "Direção de Ordem",
tipo_campo: "ordem",
order: 5,
},
filtros: { rotulo: "Filtros", tipo_campo: "lista_filtros", order: 6 },
},
},
};
export * from "./estrutura_de_campos";

327
dist-import/pilao-de-dados/visoes/listaDeVisoes.d.ts vendored Normal file
View file

@ -0,0 +1,327 @@
import { z } from "zod";
export declare const z_contagem_em_barra_vertical: z.ZodObject<{
tabela: z.ZodString;
colanuEixoX: z.ZodString;
colunaAgrupamento: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
colanuEixoX: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}, {
tabela: string;
colanuEixoX: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}>;
export declare const z_soma_em_barra_vertical: z.ZodObject<{
tabela: z.ZodString;
colanuEixoX: z.ZodString;
colunaSoma: z.ZodString;
unidadeSoma: z.ZodOptional<z.ZodString>;
colunaAgrupamento: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
colanuEixoX: string;
colunaSoma: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
unidadeSoma?: string | undefined;
}, {
tabela: string;
colanuEixoX: string;
colunaSoma: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
unidadeSoma?: string | undefined;
}>;
export declare const z_contagem_em_pizza: z.ZodObject<{
tabela: z.ZodString;
classes: z.ZodString;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
classes: string;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}, {
tabela: string;
classes: string;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}>;
export declare const z_tabela: z.ZodObject<{
tabela: z.ZodString;
colunas: z.ZodArray<z.ZodString, "many">;
coluna_ordem: z.ZodOptional<z.ZodString>;
direcao_ordem: z.ZodOptional<z.ZodEnum<["asc", "desc", "1", "-1"]>>;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
colunas: string[];
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
coluna_ordem?: string | undefined;
direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
}, {
tabela: string;
colunas: string[];
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
coluna_ordem?: string | undefined;
direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
}>;
export declare const visoes_pilao: {
z_contagem_em_barra_vertical: z.ZodObject<{
tabela: z.ZodString;
colanuEixoX: z.ZodString;
colunaAgrupamento: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
colanuEixoX: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}, {
tabela: string;
colanuEixoX: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}>;
z_contagem_em_pizza: z.ZodObject<{
tabela: z.ZodString;
classes: z.ZodString;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
classes: string;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}, {
tabela: string;
classes: string;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
}>;
z_tabela: z.ZodObject<{
tabela: z.ZodString;
colunas: z.ZodArray<z.ZodString, "many">;
coluna_ordem: z.ZodOptional<z.ZodString>;
direcao_ordem: z.ZodOptional<z.ZodEnum<["asc", "desc", "1", "-1"]>>;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
colunas: string[];
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
coluna_ordem?: string | undefined;
direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
}, {
tabela: string;
colunas: string[];
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
coluna_ordem?: string | undefined;
direcao_ordem?: "1" | "asc" | "desc" | "-1" | undefined;
}>;
z_soma_em_barra_vertical: z.ZodObject<{
tabela: z.ZodString;
colanuEixoX: z.ZodString;
colunaSoma: z.ZodString;
unidadeSoma: z.ZodOptional<z.ZodString>;
colunaAgrupamento: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
filtros: z.ZodOptional<z.ZodArray<z.ZodObject<{
coluna: z.ZodString;
valor: z.ZodAny;
operador: z.ZodEnum<["=", "!=", ">", "<", ">=", "<=", "∩"]>;
}, "strip", z.ZodTypeAny, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}, {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}>, "many">>;
descricao_pelo_usuario: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
tabela: string;
colanuEixoX: string;
colunaSoma: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
unidadeSoma?: string | undefined;
}, {
tabela: string;
colanuEixoX: string;
colunaSoma: string;
colunaAgrupamento?: string[] | undefined;
filtros?: {
coluna: string;
operador: "=" | "!=" | ">" | "<" | ">=" | "<=" | "∩";
valor?: any;
}[] | undefined;
descricao_pelo_usuario?: string | undefined;
unidadeSoma?: string | undefined;
}>;
};

38
dist-import/pilao-de-dados/visoes/listaDeVisoes.js Normal file
View file

@ -0,0 +1,38 @@
import { z } from "zod";
import { z_filtro } from "../_serie_consultar";
export const z_contagem_em_barra_vertical = z.object({
tabela: z.string(),
colanuEixoX: z.string(),
colunaAgrupamento: z.string().array().optional(),
filtros: z_filtro.array().optional(),
descricao_pelo_usuario: z.string().optional(),
});
export const z_soma_em_barra_vertical = z.object({
tabela: z.string(),
colanuEixoX: z.string(),
colunaSoma: z.string(),
unidadeSoma: z.string().optional(),
colunaAgrupamento: z.string().array().optional(),
filtros: z_filtro.array().optional(),
descricao_pelo_usuario: z.string().optional(),
});
export const z_contagem_em_pizza = z.object({
tabela: z.string(),
classes: z.string(),
filtros: z_filtro.array().optional(),
descricao_pelo_usuario: z.string().optional(),
});
export const z_tabela = z.object({
tabela: z.string(),
colunas: z.string().array(),
coluna_ordem: z.string().optional(),
direcao_ordem: z.enum(["asc", "desc", "1", "-1"]).optional(),
filtros: z_filtro.array().optional(),
descricao_pelo_usuario: z.string().optional(),
});
export const visoes_pilao = {
z_contagem_em_barra_vertical,
z_contagem_em_pizza,
z_tabela,
z_soma_em_barra_vertical,
};

21
dist-import/pilao-de-dados/visoes/tipagem.d.ts vendored Normal file
View file

@ -0,0 +1,21 @@
import { z } from "zod";
import type { visoes_pilao } from "./listaDeVisoes";
export declare const z_tipos_campos_reg_grafico: z.ZodEnum<["tabela", "coluna", "texto", "lista_colunas", "lista_filtros", "ordem"]>;
export type tipo_estrutura_visao_grafico<T extends keyof typeof visoes_pilao> = {
/** Nome da Visão */
visao: T;
/** Rotulo */
rotulo: string;
/** Retorna a tabela Referente ao Registro */
tabela: (_: z.infer<(typeof visoes_pilao)[T]>) => string;
/** Descrição */
descricao: (_: z.infer<(typeof visoes_pilao)[T]>) => string;
/** Lista os campos e suas configurações */
campos: {
[c in keyof Required<z.infer<(typeof visoes_pilao)[T]>>]: {
rotulo: string;
tipo_campo: z.infer<typeof z_tipos_campos_reg_grafico>;
order: number;
};
};
};

9
dist-import/pilao-de-dados/visoes/tipagem.js Normal file
View file

@ -0,0 +1,9 @@
import { z } from "zod";
export const z_tipos_campos_reg_grafico = z.enum([
"tabela",
"coluna",
"texto",
"lista_colunas",
"lista_filtros",
"ordem",
]);