public async Task <string> InserirRegistroAsync(Dictionary <string, string> valores, int idUsuario)
{
string retorno = string.Empty;
try
{
SqlClient.Repositorio repositorio = new SqlClient.Repositorio(IdServidor);
AlteracaoRegistroCore alteracaoRegistro = new AlteracaoRegistroCore(Colunas, valores, false);
var valoresTratados = alteracaoRegistro.GetValoresTratados();
var query = await RetornarInsertAsync(valoresTratados);
var usuario = await new SQLiteCore().RetornarNomeUsuario(idUsuario);
var dadosLog = new DadosLog()
{
Database = this.Database,
Schema = this.Schema,
Tabela = Nome,
Metodo = "InserirRegistroAsync",
Query = query,
Usuario = usuario
};
retorno = await repositorio.AlterarIncluirValoresAsync(query, dadosLog);
}
catch (Exception ex)
{
throw ex;
}
return(retorno);
}
public async Task <JsonResult> GravarConfiguracoesTabela(string dados, string dadosfk, string dadosfiltro)
{
try
{
var idServidor = HttpContext.Session.GetInt32("idServidor").Value;
Repo.Repositorio repositorio = new Repo.Repositorio(idServidor);
if (!string.IsNullOrEmpty(dados))
{
var dadosBanco = dados.Split("|")[0];
var colunas = dados.Split("|")[1];
var database = dadosBanco.Split(";")[0];
var schema = dadosBanco.Split(";")[1];
var tabela = dadosBanco.Split(";")[2];
await _tabelaCore.CarregarAsync(tabela, schema, database, idServidor);
await _tabelaCore.SalvarConfiguracoesColunasAsync(colunas.Split(";").ToList(), dadosfk?.Split(";").ToList(), dadosfiltro?.Split(";").ToList());
}
else
{
return(Json(new { result = false, message = "Dados vazios!" }));
}
}
catch (Exception ex)
{
return(Json(new { result = false, message = ex.Message }));
}
return(Json(new { result = true, message = string.Empty }));
}
public async Task <string[]> DeletarRegistroAsync(int idServidor, string pk, int idUsuario)
{
var repositorio = new SqlClient.Repositorio(idServidor);
string[] retorno = { string.Empty, string.Empty, string.Empty };
var query = RetornarDelete(pk);
try
{
var usuario = await new SQLiteCore().RetornarNomeUsuario(idUsuario);
var dadosLog = new DadosLog()
{
Database = this.Database,
Schema = this.Schema,
Tabela = Nome,
Metodo = "DeletarRegistroAsync",
Query = query,
Usuario = usuario
};
retorno = await repositorio.DeletarRegistroAsync(query, dadosLog);
}
catch (Exception ex)
{
retorno[0] = "Erro ao deletar o registro.";
retorno[1] = ex.Message;
retorno[2] = query;
}
return(retorno);
}
public async Task CarregarValoresAsync(bool amostra = false, string pk = "")
{
var repositorio = new SqlClient.Repositorio(IdServidor);
var query = string.Empty;
var where = string.Empty;
try
{
where = MontarWhereChavesPrimarias(pk);
query = await RetornarSelectAsync(where, amostra, true);
if (amostra)
{
ValoresMultilinha = await repositorio.RetornarValoresQueryAsync(query);
ConsultaDados = await repositorio.RetornarValoresMultilinha(query);
}
else
{
Valores = await repositorio.RetornarValoresAsync(query);
pkAlteracao = pk;
}
}
catch (Exception)
{
throw;
}
}
public async Task CarregarColunasFiltro()
{
var repositorio = new SqlClient.Repositorio(IdServidor);
var colunasFiltro = await repositorio.SelecionarColunasFiltroAsync(Database, Schema, Nome);
colunasFiltro.ForEach(col => col = col.ToUpper());
ColunasFiltro = TodasColunas.Where(p => colunasFiltro.Contains(p.Nome.ToUpper())).ToList();
}
public async Task <JsonResult> SelecionarColunasChaveEstrangeira(string database, string schema, string tabela)
{
var idServidor = HttpContext.Session.GetInt32("idServidor").Value;
Repo.Repositorio repositorio = new Repo.Repositorio(idServidor);
var consulta = (await repositorio.RetornarColunasAsync(database, schema, tabela)).Where(p => p.IsChaveEstrangeira).ToList();
List <ColunaChaveEstrangeiraViewModel> colunas = new List <ColunaChaveEstrangeiraViewModel>();
await _tabelaCore.CarregarAsync(tabela, schema, database, idServidor);
var id = await repositorio.SelecionarIdConfiguracaoTabelaAsync(database, schema, tabela);
string colDescricao = string.Empty;
List <string> colsList = null;
if (id > 0)
{
colsList = await repositorio.SelecionarColunasChaveEstrangeiraAsync(id);
}
if (consulta.Count > 0)
{
for (int contador = 0; contador < consulta.Count; contador++)
{
var tabelaReferenciadaChavePrimaria = _tabelaCore.TodasColunas.Where(c => c.Nome == consulta[contador].Nome).FirstOrDefault()?.TabelaReferenciadaChavePrimaria;
var colunasTabelaReferenciada = (await repositorio.RetornarColunasAsync(database, schema, tabelaReferenciadaChavePrimaria)).Select(p => p.Nome).ToList();
if (colsList != null)
{
if (colsList.Where(p => p.Split(":")[0].Equals(consulta[contador].Nome)).FirstOrDefault() != null)
{
colDescricao = colsList.Where(p => p.Split(":")[0].Equals(consulta[contador].Nome)).FirstOrDefault().Split(":")[1];
}
else
{
colDescricao = consulta[contador].Nome;
}
}
colunas.Add(new ColunaChaveEstrangeiraViewModel()
{
Nome = consulta[contador].Nome,
TabelaReferenciada = consulta[contador].TabelaReferenciada,
ColunaReferenciada = consulta[contador].ColunaReferenciada,
ColunasTabelaReferenciada = colunasTabelaReferenciada,
IndiceColTabelaReferenciada = colunasTabelaReferenciada.IndexOf(colDescricao) == -1 ? 0 : colunasTabelaReferenciada.IndexOf(colDescricao)
});
}
}
return(Json(colunas));
}
public async Task <List <string> > RetornarColunasFiltroAsync()
{
var repositorio = new SqlClient.Repositorio(IdServidor);
List <string> colFiltroList = new List <string>();
var id = await repositorio.SelecionarIdConfiguracaoTabelaAsync(Database, Schema, Nome);
if (id > 0)
{
colFiltroList = await repositorio.SelecionarColunasFiltroAsync(id);
}
return(colFiltroList);
}
public async Task CarregarValoresAsync(string query)
{
var repositorio = new SqlClient.Repositorio(IdServidor);
var where = string.Empty;
try
{
ValoresMultilinha = await repositorio.RetornarValoresQueryAsync(query);
ConsultaDados = await repositorio.RetornarValoresMultilinha(query);
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> ConsultarDadosIndex(string database, string schema, string tabela)
{
var idServidor = HttpContext.Session.GetInt32("idServidor").Value;
var repositorio = new Repo.Repositorio(idServidor);
try
{
ViewBag.Title = tabela;
await _tabelaCore.CarregarAsync(tabela, schema, database, idServidor);
await _tabelaCore.CarregarValoresAsync(true);
}
catch (Exception)
{
throw;
}
return(Json(_tabelaCore));
}
public async Task <IActionResult> Novo(string database, string schema, string tabela)
{
var idServidor = HttpContext.Session.GetInt32("idServidor").Value;
var repositorio = new Repo.Repositorio(idServidor);
try
{
await _tabelaCore.CarregarAsync(tabela, schema, database, idServidor);
ViewBag.Alterar = false;
ViewBag.UrlBack = $"/CadDinamico/Index?database={database}&schema={schema}&tabela={tabela}";
}
catch (Exception)
{
throw;
}
return(View("TelaDinamicaInclusao", _tabelaCore));
}
public async Task SalvarConfiguracoesColunasAsync(List <string> colunasVisiveis, List <string> colunasChave, List <string> colunasFiltro)
{
try
{
var repositorio = new SqlClient.Repositorio(IdServidor);
var idConfiguracaoTabela = await repositorio.SelecionarIdConfiguracaoTabelaAsync(Database, Schema, Nome);
var idConfiguracaoTabelaColuna = 0;
await repositorio.SalvarConfiguracoesTabelaAsync(idConfiguracaoTabela, Database, Schema, Nome);
idConfiguracaoTabela = await repositorio.SelecionarIdConfiguracaoTabelaAsync(Database, Schema, Nome);
foreach (var coluna in TodasColunas)
{
var visivel = colunasVisiveis.Contains(coluna.Nome);
var filtro = colunasFiltro?.Contains(coluna.Nome) ?? false;
var chave = string.Empty;
if (colunasChave != null)
{
foreach (var item in colunasChave)
{
if (chave == string.Empty)
{
if (item.Split(":")[0] == coluna.Nome)
{
chave = item.Split(":")[1];
}
}
}
}
idConfiguracaoTabelaColuna = await repositorio.SelecionarIdConfiguracaoTabelaColunaAsync(Database, Schema, Nome, coluna.Nome);
await repositorio.SalvarConfiguracaoColunaAsync(idConfiguracaoTabelaColuna, idConfiguracaoTabela, coluna.Nome, visivel, chave, filtro);
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <JsonResult> SelecionarTabelas(string database, string schema)
{
var idServidor = HttpContext.Session.GetInt32("idServidor").Value;
Repo.Repositorio repositorio = new Repo.Repositorio(idServidor);
var consulta = await repositorio.RetornarTabelasAsync(database, schema);
List <SchemaViewModel> schemas = new List <SchemaViewModel>();
if (consulta.Count > 0)
{
for (int contador = 0; contador < consulta.Count; contador++)
{
schemas.Add(new SchemaViewModel()
{
Name = consulta[contador].Nome
});
}
}
return(new JsonResult(schemas));
}
public async Task <JsonResult> SelecionarDatabases()
{
var idServidor = HttpContext.Session.GetInt32("idServidor").Value;
Repo.Repositorio repositorio = new Repo.Repositorio(idServidor);
var consulta = await repositorio.RetornarDatabasesAsync();
List <DatabaseViewModel> databases = new List <DatabaseViewModel>();
if (consulta.Count > 0)
{
for (int contador = 0; contador < consulta.Count; contador++)
{
databases.Add(new DatabaseViewModel()
{
Name = consulta[contador].Nome
});
}
}
return(new JsonResult(databases));
}
public async Task <string> PesquisarRegistrosAsync(Dictionary <string, string> valores)
{
string retorno = string.Empty;
try
{
SqlClient.Repositorio repositorio = new SqlClient.Repositorio(IdServidor);
AlteracaoRegistroCore alteracaoRegistro = new AlteracaoRegistroCore(TodasColunas, valores, true);
var valoresTratados = alteracaoRegistro.GetValoresTratados();
var where = MontarWhere(valoresTratados);
var query = await RetornarSelectAsync(where, false, false);
await CarregarValoresAsync(query);
}
catch (Exception ex)
{
throw ex;
}
return(retorno);
}
private async Task <List <TabelaEstrangeira> > RetornarListaTabelaEstrangeira(string tabela)
{
List <TabelaEstrangeira> itens = null;
var repositorio = new SqlClient.Repositorio(IdServidor);
string chavePrimaria = "";
string descricao = "";
try
{
chavePrimaria = (await repositorio.RetornarColunasChavePrimariaTabelaAsync(tabela, Schema, Database))[0].Nome;
descricao = await repositorio.SelecionarDescricaoChaveEstrangeiraConfiguracaoTabelaAsync(Database, Schema, Nome, chavePrimaria);
if (string.IsNullOrEmpty(descricao))
{
descricao = (await repositorio.RetornarColunasAsync(Database, Schema, tabela)).FirstOrDefault().Nome;
}
itens = await repositorio.SelectTabelaAsync(chavePrimaria, descricao, tabela, Schema, Database);
}
catch (Exception)
{
throw;
}
return(itens);
}
public async Task <string> CarregarAsync(string tabela, string schema, string database, int idServidor, bool carregarFks = true)
{
Nome = tabela;
Schema = schema;
Database = database;
IdServidor = idServidor;
Valores = new List <object>();
string retorno = string.Empty;
SqlClient.Repositorio repositorio = new SqlClient.Repositorio(IdServidor);
if (string.IsNullOrEmpty(Database))
{
throw new ArgumentException("Propriedade Database é obrigatória.");
}
if (string.IsNullOrEmpty(Nome))
{
throw new ArgumentException("Propriedade Nome da tabela é obrigatória.");
}
if (string.IsNullOrEmpty(Schema))
{
Schema = "DBO";
}
try
{
Valores = null;
ValoresMultilinha = null;
ConsultaDados = null;
pkAlteracao = string.Empty;
Colunas = await repositorio.RetornarColunasAsync(Database, Schema, Nome);
TodasColunas = new List <Coluna>();
TodasColunas.AddRange(Colunas);
CarregarNomesInput();
TemChavePrimaria = Colunas.Where(p => p.IsChavePrimaria).FirstOrDefault() != null;
TemChaveEstrangeira = Colunas.Where(p => p.IsChaveEstrangeira).FirstOrDefault() != null;
camposExibir = await repositorio.SelecionarColunasVisiveisAsync(Database, Schema, Nome);
ChavesPrimarias = await repositorio.RetornarColunasChavePrimariaTabelaAsync(Nome, Schema, Database);
RemoverColunasIgnoradas();
QuantidadeCampos = Colunas.Count;
if (carregarFks)
{
await CarregarColunasChaveEstrangeiraAsync();
}
IsIdentity = Colunas.FirstOrDefault().IsIdentity;
await CarregarColunasFiltro();
}
catch (Exception ex)
{
retorno = ex.Message;
}
return(retorno);
}
public async Task <string> RetornarSelectAsync(string where, bool amostra, bool limitarUm)
{
var repositorio = new SqlClient.Repositorio(IdServidor);
string query = string.Empty;
int countTabelasEstrangeiras = 0;
const string prefixoAlias = "AL";
var id = await repositorio.SelecionarIdConfiguracaoTabelaAsync(Database, Schema, Nome);
string colDescricao = string.Empty;
List <string> colsList = null;
/* Dá TOP(10) quando não tiver where definido */
if (!limitarUm && where == string.Empty)
{
amostra = true;
}
if (id > 0)
{
colsList = await repositorio.SelecionarColunasChaveEstrangeiraAsync(id);
}
query = "SELECT " + (amostra ? "TOP(10) " : (limitarUm ? "TOP(1) " : ""));
/* Montar Select da PK */
if (Colunas.Where(p => p.IsChavePrimaria).Count() > 0)
{
for (int i = 0; i < Colunas.Count; i++)
{
if (Colunas[i].IsChavePrimaria)
{
query += $"'{Colunas[i].Nome}:' + CAST(AL0.{Colunas[i].Nome} AS VARCHAR) + ';' +";
}
}
query = query.Remove(query.Length - 8, 8);
query += " AS PK, ";
}
else
{
query += "'' AS PK, ";
}
for (int i = 0; i < Colunas.Count; i++)
{
if (Colunas[i].IsChaveEstrangeira)
{
countTabelasEstrangeiras++;
if (colsList != null)
{
if (colsList.Where(p => p.Split(":")[0].Equals(Colunas[i].Nome)).FirstOrDefault() != null)
{
colDescricao = colsList.Where(p => p.Split(":")[0].Equals(Colunas[i].Nome)).FirstOrDefault().Split(":")[1];
}
else
{
colDescricao = Colunas[i].Nome;
}
}
query += $"{prefixoAlias + countTabelasEstrangeiras.ToString()}.{colDescricao}, ";
}
else
{
query += prefixoAlias + "0." + Colunas[i].Nome + ", ";
}
}
query = query.Remove(query.Length - 2, 2);
query += string.Format(" FROM {0}.{1}.{2} {3} WITH(NOLOCK)", Database, Schema, Nome, prefixoAlias + "0");
if (countTabelasEstrangeiras > 0)
{
countTabelasEstrangeiras = 0;
for (int i = 0; i < Colunas.Count; i++)
{
if (Colunas[i].IsChaveEstrangeira)
{
countTabelasEstrangeiras++;
query += $" LEFT JOIN {Database}.{Schema}.{Colunas[i].TabelaReferenciadaChavePrimaria} {prefixoAlias + countTabelasEstrangeiras.ToString()} ";
query += $" WITH(NOLOCK) ON {prefixoAlias + countTabelasEstrangeiras.ToString()}.{Colunas[i].ColunaReferenciadaChavePrimaria} = {prefixoAlias + "0"}.{Colunas[i].Nome}";
}
}
}
if (!string.IsNullOrWhiteSpace(where))
{
query += " WHERE " + where;
}
return(query);
}
public async Task <string> RetornarInsertAsync(Dictionary <string, object> valores)
{
string query = string.Empty;
var repositorio = new SqlClient.Repositorio(IdServidor);
/* Monta cabeçalho */
query = string.Format("INSERT INTO {0}.{1}.{2} ( ", Database, Schema, Nome);
for (int cont = 0; cont < Colunas.Count; cont++)
{
if (!Colunas[cont].IsChavePrimaria)
{
query += Colunas[cont].Nome + ", ";
}
else if (Colunas[cont].IsChaveEstrangeira)
{
query += Colunas[cont].Nome + ", ";
}
else if (!IsIdentity)
{
query += Colunas[cont].Nome + ", ";
}
}
query = query.Substring(0, query.Length - 2);
query += " ) VALUES ( ";
/* Monta valores */
for (int cont = 0; cont < Colunas.Count; cont++)
{
if (!Colunas[cont].IsChavePrimaria)
{
string valorParametro = valores[Colunas[cont].Nome].ToString();
if (valorParametro.ToUpper() != "NULL")
{
if (Colunas[cont].Tipo.ToUpper() == "DATE" ||
Colunas[cont].Tipo.ToUpper() == "DATETIME" ||
Colunas[cont].Tipo.ToUpper() == "DATETIME2")
{
valorParametro = AjustarFormatoData(valorParametro);
}
if (Colunas[cont].Tipo.ToUpper() == "VARCHAR" ||
Colunas[cont].Tipo.ToUpper() == "CHAR" ||
Colunas[cont].Tipo.ToUpper() == "NVARCHAR" ||
Colunas[cont].Tipo.ToUpper() == "NCHAR" ||
Colunas[cont].Tipo.ToUpper() == "DATE" ||
Colunas[cont].Tipo.ToUpper() == "DATETIME" ||
Colunas[cont].Tipo.ToUpper() == "TIME" ||
Colunas[cont].Tipo.ToUpper() == "TIMESPAN" ||
Colunas[cont].Tipo.ToUpper() == "DATETIME2")
{
valorParametro = "'" + valorParametro + "'";
}
else if (Colunas[cont].Tipo.ToUpper() == "BIT")
{
if (valorParametro.ToUpper() == bool.TrueString.ToUpper() || valorParametro.ToUpper() == "ON")
{
valorParametro = "1";
}
else
{
valorParametro = "0";
}
}
}
query += valorParametro + ", ";
}
else // Tratar chave primária
{
if (Colunas[cont].IsChaveEstrangeira)
{
string valorParametro = valores[Colunas[cont].Nome].ToString();
query += valorParametro + ", ";
}
else if (!IsIdentity)
{
string valorParametro = (await repositorio.RetornarProximaChavePrimaria(Database, Schema, Nome,
Colunas[cont].Nome)).ToString();
query += valorParametro + ", ";
}
}
}
query = query.Substring(0, query.Length - 2);
query += " )";
return(query);
}
public async Task <int> RetornarIdConfiguracaoTabelaAsync()
{
var repositorio = new SqlClient.Repositorio(IdServidor);
return(await repositorio.SelecionarIdConfiguracaoTabelaAsync(Database, Schema, Nome));
}