public ActionResult InserirTabelas(FormCollection form, MetricasIn metricasIn)
{
var nomeSplit = form["NomeTabela"].Split(',');
var atributosSplit = form["QuantidadeAtributos"].Split(',');
metricasIn.TabelaDominio = nomeSplit.Select((t, i) => new TabelaDominio
{
NomeTabela = t,
QuantidadeAtributos = int.Parse(atributosSplit[i]),
}).ToList();
/* Adiciona Tabela Geral, calculando como base a quantidade de atributos GERAL*/
metricasIn.TabelaDominio.Add(new TabelaDominio
{
NomeTabela = "Geral",
QuantidadeAtributos = metricasIn.TabelaDominio.Select(x => x.QuantidadeAtributos).Sum()
});
var TabelaDominioContainer = new Gerenciar().Inserir(metricasIn);
/* Armazena em Session */
HttpContext.Session["TabelaDominioContainer"] = TabelaDominioContainer;
return(RedirectToAction("Resultados"));
}
public async Task <List <Gerenciar> > GetAvaliador()
{
try
{
using (var db = new SqlConnection(_settings.ConnectionString))
{
var selectAvaliadoresId = await db.QueryAsync <long>("SELECT UserId FROM dbo.AspNetUserRoles WHERE RoleId = 3");
var avaliador = selectAvaliadoresId.ToList();
List <Gerenciar> avaliadores = new List <Gerenciar>();
foreach (var id in avaliador)
{
var selectAvaliadores = await db.QueryAsync <Gerenciar>("SELECT * FROM dbo.AspNetUsers WHERE Id = @avaliadorId",
new
{
avaliadorId = id
});
Gerenciar aval = selectAvaliadores.FirstOrDefault();
if (aval != null)
{
avaliadores.Add(aval);
}
}
return(avaliadores);
}
}
catch (Exception ex)
{
return(null);
}
}
public async Task <IActionResult> GerenciarOrganizador()
{
var user = await _userManager.FindByNameAsync(User.Identity.Name);
var organizadores = await _administradorServices.GetOrganizador();
List <Gerenciar> model = new List <Gerenciar>();
foreach (var organizador in organizadores)
{
var isAvaliador = await _administradorRepository.IsAvaliador(organizador.Id);
var organizadorConsulta = new Gerenciar()
{
Id = organizador.Id,
Nome = organizador.Nome,
Sobrenome = organizador.Sobrenome,
PhoneNumber = organizador.PhoneNumber,
Celular = organizador.Celular,
DataNascimento = organizador.DataNascimento,
Email = organizador.Email,
Genero = organizador.Genero,
CPF = organizador.CPF,
Avaliador = isAvaliador,
FirstAccess = organizador.FirstAccess
};
model.Add(organizadorConsulta);
}
return(View(model));
}
public async Task <IActionResult> CadastrarOrganizador()
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var areaConhecimento = await _areaRepository.GetAreas();
var eventos = await _eventoRepository.getEventos();
Gerenciar model = new Gerenciar()
{
AreaConhecimento = areaConhecimento,
Eventos = eventos,
};
return(View(model));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> InformacaoAutor(long id)
{
Gerenciar autores = await _administradorRepository.GetAutor(id);
Gerenciar endereco = await _localizacaoRepository.GetEndereco(autores.EnderecoId);
var instituicao = await _administradorRepository.GetInstituicao(autores.InstituicaoId);
var cidade = await _localizacaoRepository.GetCidade(endereco.CidadeId);
var estado = await _localizacaoServices.GetEstado(cidade.Id);
var model = new Gerenciar()
{
Nome = autores.Nome,
Sobrenome = autores.Sobrenome,
PhoneNumber = autores.PhoneNumber,
Celular = autores.Celular,
CPF = autores.CPF,
Email = autores.Email,
Nascimento = autores.DataNascimento.ToString("dd/MM/yyyy"),
Genero = autores.Genero,
Logradouro = endereco.Logradouro,
Bairro = endereco.Bairro,
CidadeNome = cidade.CidadeNome,
Sigla = estado.Sigla,
Numero = endereco.Numero,
InstituicaoNome = instituicao
};
return(Json(model));
}
public async Task <IActionResult> GerenciarAvaliador()
{
var user = await _userManager.FindByNameAsync(User.Identity.Name);
var avaliadores = await _administradorServices.GetAvaliador();
List <Gerenciar> model = new List <Gerenciar>();
foreach (var avaliador in avaliadores)
{
var evento = await _administradorServices.GetEvento(avaliador.Id);
var subAreaConhecimento = await _administradorServices.GetSubAreaConhecimento(avaliador.Id);
var avaliadorConsulta = new Gerenciar()
{
Id = avaliador.Id,
Nome = avaliador.Nome,
Sobrenome = avaliador.Sobrenome,
PhoneNumber = avaliador.PhoneNumber,
Email = avaliador.Email,
Evento = evento,
SubAreaConhecimento = subAreaConhecimento,
FirstAccess = avaliador.FirstAccess
};
model.Add(avaliadorConsulta);
}
return(View(model));
}
public async Task <IActionResult> CadastrarOrganizador(Gerenciar model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = new ApplicationUser
{
Email = model.Email,
NormalizedEmail = model.Email.ToUpper(),
UserName = model.Email,
NormalizedUserName = model.Email.ToUpper(),
DataCadastro = DateTime.Now,
Nome = model.Nome,
Sobrenome = model.Sobrenome,
PhoneNumber = model.PhoneNumber,
Celular = model.Celular,
CursosId = 1,
InstituicaoId = 1,
EnderecoId = 1,
FirstAccess = true
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "ORGANIZADOR");
//link
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action(
"ConfirmEmail", "Account",
new { user = user.UserName, code = code });
var url = $"{urlRoot}{callbackUrl}";
//email
var email = await _emailServices.EnviarEmail(user.Email, url);
ViewBag.Cadastrado = "cadastrado";
return(View("GerenciarOrganizador", new List <Gerenciar>()));
}
else
{
await _userManager.DeleteAsync(user);
ViewBag.Errors = result.ConvertToHTML();
return(View("CadastrarOrganizador", model));
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> ConsultarUsuario()
{
var user = await _userManager.FindByNameAsync(User.Identity.Name);
var usuarios = await _organizadorRepository.GetUsuarios();
List <Gerenciar> model = new List <Gerenciar>();
foreach (var usuario in usuarios)
{
var isAvaliador = await _administradorRepository.IsAvaliador(usuario.Id);
var usuarioConsulta = new Gerenciar()
{
Id = usuario.Id,
Nome = usuario.Nome,
Sobrenome = usuario.Sobrenome,
PhoneNumber = usuario.PhoneNumber,
Celular = usuario.Celular,
DataNascimento = usuario.DataNascimento,
Email = usuario.Email,
Genero = usuario.Genero,
CPF = usuario.CPF,
Avaliador = isAvaliador,
FirstAccess = usuario.FirstAccess
};
model.Add(usuarioConsulta);
}
return(View(model));
}
public async Task <IActionResult> InformacaoUsuario(long id)
{
Gerenciar usuarios = await _organizadorRepository.GetUsuarios(id);
Gerenciar endereco = await _localizacaoRepository.GetEndereco(usuarios.EnderecoId);
var cidade = await _localizacaoRepository.GetCidade(endereco.CidadeId);
var estado = await _localizacaoServices.GetEstado(cidade.Id);
var isAvaliador = await _administradorRepository.IsAvaliador(usuarios.Id);
var isAdministrador = await _administradorRepository.IsAdministrador(usuarios.Id);
var isAutor = await _administradorRepository.IsAutor(usuarios.Id);
var isOrganizador = await _administradorRepository.IsOrganizador(usuarios.Id);
var model = new Gerenciar()
{
Nome = usuarios.Nome,
Sobrenome = usuarios.Sobrenome,
PhoneNumber = usuarios.PhoneNumber,
Celular = usuarios.Celular,
CPF = usuarios.CPF,
Email = usuarios.Email,
Nascimento = usuarios.DataNascimento.ToString("dd/MM/yyyy"),
Genero = usuarios.Genero,
Avaliador = isAvaliador,
Autor = isAutor,
Administrador = isAdministrador,
Organizador = isOrganizador,
Logradouro = endereco.Logradouro,
Bairro = endereco.Bairro,
CidadeNome = cidade.CidadeNome,
Sigla = estado.Sigla,
Numero = endereco.Numero,
};
return(Json(model));
}
public void CalcularTiposTabela()
{
var TabelaDominioContainer = TabelaDefault();
var calcularEntrada = MetricasEntrada.CalcularEntrada(TabelaDominioContainer);
ValidarEntrada(calcularEntrada);
var calcularSaida = MetricasSaida.CalcularSaida(TabelaDominioContainer);
ValidarSaida(calcularSaida);
var calcularConsulta = MetricasConsulta.CalcularConsulta(TabelaDominioContainer);
ValidarConsulta(calcularConsulta);
var calcularArquivo = MetricasArquivo.CalcularArquivo(TabelaDominioContainer);
ValidarArquivo(calcularArquivo);
var calcularInterface = MetricasInterface.CalcularInterface(TabelaDominioContainer);
ValidarInterface(calcularInterface);
var TabelasBrutas = new TabelasBrutas
{
TabelaEntrada = calcularEntrada,
TabelaSaida = calcularSaida,
TabelaConsulta = calcularConsulta,
TabelaArquivo = calcularArquivo,
TabelaInterface = calcularInterface
};
var calcularFPB = new Gerenciar().CalcularFPB(TabelasBrutas);
ValidarFPB(calcularFPB);
var valorBase = Math.Round(MetricasBase.CalcularBase(calcularFPB));
}
