public CommonRestModel GuardarUsuarioEmpresa(SaveUsuarioEmpresaParameters usuarioEmpresa)
{
var res = new CommonRestModel();
var usuariosEmpresas = _dbContext.UsuariosEmpresas.Where(a => a.UsuarioId == usuarioEmpresa.IdUsuario).ToList();
_dbContext.UsuariosEmpresas.RemoveRange(usuariosEmpresas);
foreach (var empresa in usuarioEmpresa.IdsEmpresas)
{
var usuarioEmp = new UsuarioEmpresa
{
UsuarioId = usuarioEmpresa.IdUsuario,
EmpresaId = empresa,
Fecha = DateTime.Now
};
_dbContext.UsuariosEmpresas.Add(usuarioEmp);
}
_dbContext.SaveChanges();
res.CodigoResultado = "0";
res.Mensaje = "Ok";
return(res);
}
protected void btnAlta_Click(object sender, EventArgs e)
{
UsuarioEmpresa usuempresa = null;
try
{
usuempresa = new UsuarioEmpresa
{
NombreUsuario = txtNomUsu.Text,
Contrasenia = txtContra.Text,
Nombre = txtNombre.Text,
Telefono = txtTelefono.Text,
Direccion = txtDireccion.Text,
Email = txtEmail.Text
};
}
catch (Exception ex)
{
lblMensaje.Text = ex.Message;
return;
}
try
{
UsuarioEmpleado usuLogueado = (UsuarioEmpleado)Session["Usuario"];
new ServicioClient().AgregarUsuario(usuempresa, usuLogueado);
LimpiarFormulario();
btnAlta.Enabled = false;
btnBaja.Enabled = false;
btnModificar.Enabled = false;
lblMensaje.Text = "Se ha dado de alta a la empresa " + usuempresa.Nombre;
}
catch (Exception ex)
{
lblMensaje.Text = ex.Message;
}
}
public ResultadoOperacionDto GuardarUsuarioEmpresa(UsuarioEmpresa usuarioEmpresa, long idUsuarioExec)
{
var resultado = new ResultadoOperacionDto();
try
{
var param = new List <object>()
{
Repository.ObtenerUsuarioPorId(usuarioEmpresa.IdUsuario).CorreoElectronico
};
var informacionAuditoria = new InformacionAuditoriaDto(idUsuarioExec, ConstantsAccionAuditable.Insertar, ConstantsModulo.Usuarios, usuarioEmpresa.IdUsuarioEmpresa == 0 ? MensajesServicios.InsertarUsuarioEmpresa : MensajesServicios.ActualizarUsuarioEmpresa, param);
resultado.InformacionExtra = UsuarioEmpresaRepository.GuardarUsuarioEmpresa(usuarioEmpresa);
resultado.InformacionAuditoria = informacionAuditoria;
resultado.Resultado = true;
}
catch (Exception exception)
{
resultado.Resultado = false;
resultado.Mensaje = exception.Message;
resultado.InformacionExtra = exception;
}
return(resultado);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Name, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var identityRole = db.Roles.Find(model.IdentityRoleID);
UserManager.AddToRole(user.Id, identityRole.Name);
var usuarioEmpresa = new UsuarioEmpresa
{
ApplicationUserID = user.Id, EmpresaID = model.EmpresaID
};
UsuarioEmpresasController.Create(usuarioEmpresa, db);
//await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public void DadoUmEmailNuloOConstrutorDeveRetornarUmUsuarioInvalido()
{
UsuarioEmpresa usuario = new UsuarioEmpresa(empresa, nomeContato, null, senha, senha);
Assert.IsFalse(usuario.IsValid());
}
public void AutenticadoDeveRetornarVerdadeiroSeASenhaForIgualASenhaDoUsuario()
{
UsuarioEmpresa usuario = new UsuarioEmpresa(empresa, nomeContato, email, "teste$1234*", "teste$1234*");
Assert.IsTrue(usuario.Autenticado("teste$1234*"));
}
public void AutenticadoDeveRetornarFalsoSeASenhaForDiferenteDaSenhaDoUsuario()
{
UsuarioEmpresa usuario = new UsuarioEmpresa(empresa, nomeContato, email, senha, senha);
Assert.IsFalse(usuario.Autenticado("12345"));
}
public async Task <string> EditUsuario(string id, string userName, string email,
string phoneNumber, int accessFailedCount, string concurrencyStamp, bool emailConfirmed,
bool lockoutEnabled, DateTimeOffset lockoutEnd, string normalizedEmail,
string normalizedUserName, string passwordHash, bool phoneNumberConfirmed,
string securityStamp, bool twoFactorEnabled, string selectRole, ApplicationUser applicationUser,
string selectEmpresa)
{
var resp = "";
try
{
applicationUser = new ApplicationUser
{
Id = id,
UserName = userName,
Email = email,
PhoneNumber = phoneNumber,
EmailConfirmed = emailConfirmed,
LockoutEnabled = lockoutEnabled,
LockoutEnd = lockoutEnd,
NormalizedEmail = normalizedEmail,
NormalizedUserName = normalizedUserName,
PasswordHash = passwordHash,
PhoneNumberConfirmed = phoneNumberConfirmed,
SecurityStamp = securityStamp,
TwoFactorEnabled = twoFactorEnabled,
AccessFailedCount = accessFailedCount,
ConcurrencyStamp = concurrencyStamp
};
//Actualizamos los datos
_context.Update(applicationUser);
await _context.SaveChangesAsync();
//Obtenemos el usuario
var usuario = await _userManager.FindByIdAsync(id);
usuarioRole = await _usuarioRole.GetRole(_userManager, _roleManager, id);
if (usuarioRole[0].Text != "No Role")
{
await _userManager.RemoveFromRoleAsync(usuario, usuarioRole[0].Text);
}
if (selectRole == "No Role")
{
selectRole = "No Role";
}
//Ahora si almacenamos el rol
var resultado = await _userManager.AddToRoleAsync(usuario, selectRole);
await _context.SaveChangesAsync();
try
{
UsuarioEmpresa ue = new UsuarioEmpresa();
ue.Id = applicationUser.Id;
ue.EmpresaId = int.Parse(selectEmpresa);
try
{
_context.UsuarioEmpresa.Add(ue);
await _context.SaveChangesAsync();
}
catch (Exception)
{
_context.UsuarioEmpresa.Update(ue);
await _context.SaveChangesAsync();
}
}
catch (Exception ex)
{
resp = "NoSave";
}
resp = "Save";
}
catch (Exception ex2)
{
resp = "No Save";
}
return(resp);
}
public async Task <ActionResult> Create(BOAccountCreateViewModel model)
{
ViewBag.Empresas = _Empresas;
for (int i = 0; i < model.EmpresasGrupos.Count; i++)
{
model.EmpresasGrupos[i].PerfilImpressora = PerfilImpressorasList(model.EmpresasGrupos[i].IdEmpresa, idPerfilImpressora: model.EmpresasGrupos[i].IdPerfilImpressoraPadrao);
}
Func <string, ViewResult> errorView = (error) =>
{
if (error != null)
{
Notify.Error(Resources.CommonStrings.RequestUnexpectedErrorMessage);
}
return(View(model));
};
if (!ModelState.IsValid)
{
return(errorView(null));
}
if (model.EmpresasGrupos.Any(x => x.IdPerfilImpressoraPadrao == null))
{
ModelState.AddModelError(nameof(model.EmpresasGrupos), "Selecione um Perfil de Impressão Padrão em todas as empresas.");
}
var existingUserByName = await UserManager.FindByNameAsync(model.UserName).ConfigureAwait(false);
if (existingUserByName != null)
{
ModelState.AddModelError(nameof(model.UserName), "O código de usuário informado já existe");
}
var existsUserByEmail = await UserManager.FindByEmailAsync(model.Email).ConfigureAwait(false);
if (existsUserByEmail != null)
{
ModelState.AddModelError(nameof(model.Email), "E-mail informado já utilizado por outro usuário");
}
if (model.EmpresasGrupos.NullOrEmpty())
{
ModelState.AddModelError(nameof(model.EmpresasGrupos), Res.RequiredOnlyCompany);
return(errorView(null));
}
if (!model.EmpresasGrupos.All(w => w.Grupos.Any(a => a.IsSelected)))
{
ModelState.AddModelError(nameof(model.EmpresasGrupos), Res.RequiredOnlyGroup);
return(errorView(null));
}
if (!model.EmpresasGrupos.Where(w => w.IsEmpresaPrincipal).Any())
{
ModelState.AddModelError(nameof(model.EmpresasGrupos), "Selecione a empresa principal do usuário");
return(errorView(null));
}
for (int i = 0; i < model.EmpresasGrupos.Count; i++)
{
if (model.EmpresasGrupos[0].CorredorEstoqueInicio == null && model.EmpresasGrupos[0].CorredorEstoqueFim != null)
{
ModelState.AddModelError($"[{i}].CorredorEstoque", "Preencha o valor inicial do Corredor Estoque");
}
if (model.EmpresasGrupos[0].CorredorEstoqueInicio != null && model.EmpresasGrupos[0].CorredorEstoqueFim == null)
{
ModelState.AddModelError($"[{i}].CorredorEstoque", "Preencha o valor final do Corredor Estoque");
}
if (model.EmpresasGrupos[0].CorredorEstoqueInicio.HasValue && model.EmpresasGrupos[0].CorredorEstoqueFim.HasValue)
{
if (model.EmpresasGrupos[0].CorredorEstoqueInicio.Value > model.EmpresasGrupos[0].CorredorEstoqueFim.Value)
{
ModelState.AddModelError($"[{i}].CorredorEstoque", "O valor inicial do Corredor Estoque não pode ser maior do que o final");
}
}
if (model.EmpresasGrupos[0].CorredorSeparacaoInicio == null && model.EmpresasGrupos[0].CorredorSeparacaoFim != null)
{
ModelState.AddModelError($"[{i}].CorredorSeparacao", "Preencha o valor inicial do Corredor Separação");
}
if (model.EmpresasGrupos[0].CorredorSeparacaoInicio != null && model.EmpresasGrupos[0].CorredorSeparacaoFim == null)
{
ModelState.AddModelError($"[{i}].CorredorSeparacao", "Preencha o valor final do Corredor Separação");
}
if (model.EmpresasGrupos[0].CorredorSeparacaoInicio.HasValue && model.EmpresasGrupos[0].CorredorSeparacaoFim.HasValue)
{
if (model.EmpresasGrupos[0].CorredorSeparacaoInicio.Value > model.EmpresasGrupos[0].CorredorSeparacaoFim.Value)
{
ModelState.AddModelError($"[{i}].CorredorSeparacao", "O valor inicial do Corredor Separação não pode ser maior do que o final");
}
}
}
if (!ModelState.IsValid)
{
return(errorView(null));
}
var user = new ApplicationUser {
UserName = model.UserName, Email = model.Email
};
user.Id = Guid.NewGuid().ToString();
var result = await UserManager.CreateAsync(user, model.Password).ConfigureAwait(false);
if (!result.Succeeded)
{
throw new InvalidOperationException(Resources.CommonStrings.RequestUnexpectedErrorMessage);
}
var perfilUsuario = new PerfilUsuario
{
Ativo = model.Ativo,
Cargo = model.Cargo,
DataNascimento = model.DataNascimento,
Departamento = model.Departamento,
Nome = model.Nome,
UsuarioId = user.Id,
EmpresaId = model.EmpresasGrupos.Where(w => w.IsEmpresaPrincipal).First().IdEmpresa
};
_unitOfWork.PerfilUsuarioRepository.Add(perfilUsuario);
_unitOfWork.SaveChanges();
foreach (var f in model.EmpresasGrupos)
{
var newUsuarioEmpresa = new UsuarioEmpresa
{
UserId = user.Id,
IdEmpresa = f.IdEmpresa,
PerfilUsuarioId = perfilUsuario.PerfilUsuarioId,
IdPerfilImpressoraPadrao = f.IdPerfilImpressoraPadrao,
CorredorEstoqueInicio = f.CorredorEstoqueInicio,
CorredorEstoqueFim = f.CorredorEstoqueFim,
CorredorSeparacaoInicio = f.CorredorSeparacaoInicio,
CorredorSeparacaoFim = f.CorredorSeparacaoFim,
};
_unitOfWork.UsuarioEmpresaRepository.Add(newUsuarioEmpresa);
}
_unitOfWork.SaveChanges();
var empresasGruposNew = new StringBuilder();
foreach (var item in model.EmpresasGrupos.Where(x => x.Grupos.Any(y => y.IsSelected)))
{
IEnumerable <string> selectedRoles = item.Grupos.Where(x => x.IsSelected).Select(x => x.Name);
empresasGruposNew.AppendLine(string.Format("{0}: {1}", item.Nome, string.Join(", ", selectedRoles.ToArray())));
empresasGruposNew.AppendLine(" || ");
result = UserManager.AddToRolesByEmpresa(user, selectedRoles.ToArray(), item.IdEmpresa);
if (!result.Succeeded)
{
Notify.Error(Resources.CommonStrings.RequestUnexpectedErrorMessage);
return(View(model));
}
}
var userInfo = new BackOfficeUserInfo();
Notify.Success(Resources.CommonStrings.RegisterCreatedSuccessMessage);
return(RedirectToAction("Index"));
}
List <SolicitudEntrega> IServicio.ListarSolicitudEntregaEmpresaLogueada(UsuarioEmpresa ULogueado)
{
return(Fabrica.GetLS().ListarSolicitudEntregaEmpresaLogueada(ULogueado));
}
public void DadaUmaSenhaDiferenteDaConfirmacaoDeSenhaOConstrutorDeveRetornarUmUsuarioInvalido()
{
UsuarioEmpresa usuario = new UsuarioEmpresa(empresa, nomeContato, email, senha, "12345");
Assert.IsFalse(usuario.IsValid());
}
public void autenticar(object sender, EventArgs e)
{
string senhaPost = (senha.Value);
string loginPost = (login.Value);
//ANTI INJECTION
int lenS = senhaPost.Length; if (lenS >= 10)
{
lenS = 10;
}
int lenL = loginPost.Length; if (lenL >= 12)
{
lenS = 12;
}
senhaPost = senhaPost.Substring(0, lenS);
loginPost = loginPost.Substring(0, lenL);
senhaPost = senhaPost.Replace("'", "0");
loginPost = loginPost.Replace("'", "0");
senhaPost = senhaPost.Replace('"', '0');
loginPost = loginPost.Replace('"', '0');
senhaPost = senhaPost.Replace("/", "0");
loginPost = loginPost.Replace("/", "0");
senhaPost = senhaPost.Replace("=", "0");
loginPost = loginPost.Replace("=", "0");
loginPost = loginPost.Replace(" OR ", "0");
Usuario logando = new Usuario();
logando.Login = loginPost;
logando.Senha = senhaPost;
LoginClienteValidator validator = new LoginClienteValidator();
ValidationResult result = validator.Validate(logando);
if (result.IsValid)
{
logando = new UsuarioDAO().selectUserLogin(loginPost);
UsuarioEmpresa empresa = new UsuarioEmpresa();
empresa = new UsuarioEmpresaDAO().selectUserIdUser(logando.Id);
if (logando.Block != 1)
{
String senha = logando.Senha;
if (senha.Equals(senhaPost))
{
if (empresa.Id > 0)
{
mensagem = "Login e senha OK";
Session["sId"] = logando.Id;
Session["sNome"] = logando.Nome;
Session["sNivelEmp"] = empresa.NivelEmp;
Session["sFuncao"] = empresa.Funcao;
Session["sIdEmp"] = empresa.IdEmpresa;
Session.Timeout = 20;
new LogDAO().logit("Login Empresa", (int)logando.Id);
Response.Redirect("indexPrestador.aspx");
}
else
{
mensagem = "Você não está cadastrado em uma empresa";
++contaErros;
logando = null;
if (contaErros >= 5)
{
mensagem = "Tentativas esgotadas";
}
}
}
else
{
mensagem = "Dados Incorretos";
++contaErros;
logando = null;
if (contaErros >= 5)
{
mensagem = "Tentativas esgotadas";
}
}
}
else
{
mensagem = "Usuario Bloqueado";
}
}
else
{
mensagem = result.ToString(" & ");
}
}
public void Add()
{
string userName = HttpContext.Current.User.Identity.Name;
var resultpc = pc.BuscarSiExistePersona(txtCI.Text); //Si existe y esta activo
if (resultpc == null)
{
//si no esta activo
if (!pc.BuscarSiEstaRegistradoPersona(txtCI.Text))
{
Persona p = new Persona()
{
CI = txtCI.Text,
Nombre = txtNombre.Text,
ApellidoP = txtApellidop.Text,
ApellidoM = txtApellidom.Text,
Direccion = txtdireccion.Text,
Telefono = txttelefono.Text,
Email = txtEmail.Text,
Contacto = "",
TelfContacto = "",
Estado = true,
CodTipo = Convert.ToInt32(cboTipop.SelectedValue.ToString()),
CategoriaL = "",
IdUser = null,
UsuaReg = userName,
FechaReg = DateTime.Now
};
bool ok = false;
int tipoPersona = Convert.ToInt32(cboTipop.SelectedValue);
switch (tipoPersona)
{
case 1:
ok = true;
break;
case 2:
try
{
var manager = Context.GetOwinContext().GetUserManager <ApplicationUserManager>();
var user = new ApplicationUser()
{
UserName = UserName.Text, Email = txtEmail.Text, EmailConfirmed = true
};
IdentityResult result = manager.Create(user, Password.Text);
if (result.Succeeded)
{
string rol = Convert.ToString(dpdRoles.SelectedItem);
manager.AddToRole(user.Id, rol);
p.IdUser = user.Id;
p.Contacto = txtContacto.Text;
p.TelfContacto = txttelefonoc.Text;
ok = true;
}
else
{
ErrorMessage.Text = result.Errors.FirstOrDefault();
}
}
catch (Exception ex)
{
ErrorMessage.Text = ex.Message;
}
break;
case 3:
p.Contacto = txtContacto.Text;
p.TelfContacto = txttelefonoc.Text;
p.CategoriaL = txtlicencia.Text;
p.FechaVigL = Convert.ToDateTime(txtfechavigl.Text);
p.FechaVigDefL = Convert.ToDateTime(txtfechavigdefl.Text);
ok = true;
break;
}
if (ok)
{
ok = pc.add(p);
if (ok == true)
{
string rol = Convert.ToString(dpdRoles.SelectedItem);
if (!rol.Equals("SA"))
{
UsuarioEmpresa ue = new UsuarioEmpresa
{
NIT = homeCtrl.obtenerNit(userName),
CI = txtCI.Text,
UsuaReg = userName,
FechaReg = DateTime.Now,
Activo = false,
Estado = true
};
bool sw = pc.addUsuarioEmpresa(ue);
if (sw == true)
{
MensajeAlerta("Se registro correctamente");
Response.Redirect("~/Vistas/Personas/Index");
}
}
else
{
pc.AddAllUsuarioEmpresa(p.CI, userName);
Response.Redirect("~/Vistas/Personas/Index");
}
}
else
{
MensajeAlerta("Datos invalidos");
}
}
}
else
{
//**********************************GM**********************************************
Persona p = new Persona()
{
CI = txtCI.Text,
Nombre = txtNombre.Text,
ApellidoP = txtApellidop.Text,
ApellidoM = txtApellidom.Text,
Direccion = txtdireccion.Text,
Telefono = txttelefono.Text,
Email = txtEmail.Text,
Contacto = "",
TelfContacto = "",
Estado = true,
CodTipo = Convert.ToInt32(cboTipop.SelectedValue.ToString()),
CategoriaL = "",
IdUser = null,
UsuaReg = userName,
FechaReg = DateTime.Now
};
bool ok = false;
int tipoPersona = Convert.ToInt32(cboTipop.SelectedValue);
switch (tipoPersona)
{
case 1:
ok = true;
break;
case 2:
try
{
var manager = Context.GetOwinContext().GetUserManager <ApplicationUserManager>();
var user = new ApplicationUser()
{
UserName = UserName.Text, Email = txtEmail.Text, EmailConfirmed = true
};
IdentityResult result = manager.Create(user, Password.Text);
if (result.Succeeded)
{
string rol = Convert.ToString(dpdRoles.SelectedItem);
manager.AddToRole(user.Id, rol);
p.IdUser = user.Id;
p.Contacto = txtContacto.Text;
p.TelfContacto = txttelefonoc.Text;
ok = true;
}
else
{
ErrorMessage.Text = result.Errors.FirstOrDefault();
}
}
catch (Exception ex)
{
ErrorMessage.Text = ex.Message;
}
break;
case 3:
p.Contacto = txtContacto.Text;
p.TelfContacto = txttelefonoc.Text;
p.CategoriaL = txtlicencia.Text;
p.FechaVigL = Convert.ToDateTime(txtfechavigl.Text);
p.FechaVigDefL = Convert.ToDateTime(txtfechavigdefl.Text);
ok = true;
break;
}
if (ok)
{
ok = pc.ActualizarDatosPersona(p);
if (ok == true)
{
string rol = Convert.ToString(dpdRoles.SelectedItem);
if (!rol.Equals("SA"))
{
UsuarioEmpresa ue = new UsuarioEmpresa
{
NIT = homeCtrl.obtenerNit(userName),
CI = txtCI.Text,
UsuaReg = userName,
FechaReg = DateTime.Now,
Activo = false,
Estado = true
};
bool sw = pc.addUsuarioEmpresa(ue);
if (sw == true)
{
MensajeAlerta("Se registro correctamente");
Response.Redirect("~/Vistas/Personas/Index");
}
}
else
{
pc.AddAllUsuarioEmpresa(p.CI, userName);
Response.Redirect("~/Vistas/Personas/Index");
}
}
else
{
MensajeAlerta("Datos invalidos");
}
}
}
}
}
public void Edit(UsuarioEmpresa usuarioEmpresa, ApplicationDbContext db)
{
db.Entry(usuarioEmpresa).State = EntityState.Modified;
db.SaveChanges();
}
public static void Create(UsuarioEmpresa usuarioEmpresa, ApplicationDbContext db)
{
db.UsuarioEmpresas.Add(usuarioEmpresa);
db.SaveChanges();
}
public List <SolicitudEntrega> ListarSolicitudEntregaEmpresaLogueada(UsuarioEmpresa ULogueado)
{
return(Persistencia.Fabrica.GetPS().ListarSolicitudEntregaEmpresaLogueada(ULogueado));
}
public void DadaUmaSenhaNulaOConstrutorDeveRetornarUmUsuarioInvalido()
{
UsuarioEmpresa usuario = new UsuarioEmpresa(empresa, nomeContato, email, null, null);
Assert.IsFalse(usuario.IsValid());
}
public async Task <IActionResult> CriarUsuarioEmpresa(CriarUsuarioEmpresaInput input)
{
if (!ValidatorUtil.CnpjIsValid(input.Cnpj))
{
return(StatusCode(400, "CNPJ Inválido."));
}
var usuarioDb = _usuarioRepository.GetUsuarioByEmail(input.Email);
// Verifica se já existe um usuário com mesmo email cadastrado no sistema
if (usuarioDb != null)
{
return(StatusCode(400, $"Já existe um usuário com email [{input.Email}] no sistema."));
}
// Verifica se existe um aluno cadastrado com mesmo email
var alunoDb = _alunoRepository.BuscarPorEmail(input.Email);
if (alunoDb != null)
{
return(StatusCode(400, $"Já existe um aluno cadastrado com email [{input.Email}] no sistema."));
}
var empresaDb = _empresaRepository.GetByCNPJ(input.Cnpj);
if (empresaDb == null)
{
#region Verifica se já existe uma empresa com o mesmo CNPJ cadastrada no sistema
var responseReceita = await apiRequestService.ReceitaWS(input.Cnpj);
if (responseReceita == null)
{
return(StatusCode(400, "Ocorreu um erro na busca do CNPJ da Empresa, tente novamente mais tarde."));
}
if (responseReceita.Status.Equals("ERROR") || responseReceita.Status.Equals("CNPJ inválido") || !responseReceita.Status.Equals("OK"))
{
return(StatusCode(400, $"{responseReceita.Message}"));
}
#region Cadastra/Busca endereços e vincula-os
TipoEmpresa tipoEmpresa = null;
if (responseReceita.TipoEmpresa.ToUpper() == TipoEmpresaDefaultValuesAccess.GetValue(TipoEmpresaDefaultValues.FILIAL))
{
tipoEmpresa = _tipoEmpresaRepository.GetByDescricao(TipoEmpresaDefaultValuesAccess.GetValue(TipoEmpresaDefaultValues.FILIAL));
}
if (responseReceita.TipoEmpresa.ToUpper() == TipoEmpresaDefaultValuesAccess.GetValue(TipoEmpresaDefaultValues.MATRIZ))
{
tipoEmpresa = _tipoEmpresaRepository.GetByDescricao(TipoEmpresaDefaultValuesAccess.GetValue(TipoEmpresaDefaultValues.MATRIZ));
}
if (tipoEmpresa == null)
{
return(StatusCode(400, "Houve um erro ao adquirir o tipo da empresa."));
}
var responseViaCep = await apiRequestService.ViaCEP(FormatStringUtil.CaracterClear(responseReceita.CEP));
if (responseViaCep == null)
{
return(StatusCode(400, "Ocorreu um erro na busca do endereço da Empresa, tente novamente mais tarde."));
}
var UfSiglaDb = _enderecoRepository.GetUfSiglaBySigla(responseViaCep.UfSigla);
if (UfSiglaDb == null)
{
return(StatusCode(400, "Não existe UF's necessárias cadastradas no banco de dados, não é possível prosseguir com o cadastro da empresa."));
}
var municipioDb = _enderecoRepository.GetMunicipioByDescricao(responseViaCep.Localidade);
// Cria um novo município caso não encontre já criado no banco de dados.
if (municipioDb == null)
{
try
{
municipioDb = new Municipio(responseViaCep.Localidade, UfSiglaDb.Id);
municipioDb = _enderecoRepository.CreateMunicipio(municipioDb);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar um novo município no banco de dados para a Empresa."));
}
}
// Verifica quais campos que não estão vazios para criar o endereço
string logradouroPreenchido = string.IsNullOrEmpty(responseViaCep.Logradouro) == false ? responseViaCep.Logradouro : responseReceita.Logradouro;
string bairroPreenchido = string.IsNullOrEmpty(responseViaCep.Bairro) == false ? responseViaCep.Bairro : responseReceita.Bairro;
// Cria novo endereço para a Empresa
Endereco endereco = null;
try
{
endereco = new Endereco(responseViaCep.Cep, bairroPreenchido, logradouroPreenchido, responseReceita.Numero, municipioDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno criar um endereço para a Empresa."));
}
var enderecoDb = _enderecoRepository.Create(endereco);
#endregion
// Verifica se fantasia esta nula e substitui por nome, caso contrário, mantem fantasia
string nomeEmpresa = string.IsNullOrEmpty(responseReceita.Fantasia) ? responseReceita.Nome : responseReceita.Fantasia;
// Cria Empresa
empresaDb = null;
try
{
empresaDb = new Empresa(input.Cnpj, nomeEmpresa, enderecoDb.Id, tipoEmpresa.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar uma Empresa."));
}
// Cria Empresa no BD
empresaDb = _empresaRepository.Create(empresaDb);
#region Registra todos os TiposCnaes (Atividade Principal e Atividade Secundária)
// Default Values Atividade principal e secundária
var AtividadePrincipalDb = _tipoAtividadeCnaeRepository.GetByDescricao(TipoAtividadeCnaeDefaultValuesAccess.GetValue(TipoAtividadeCnaeDefaultValues.AtividadePrincipal));
var AtividadeSecundariaDb = _tipoAtividadeCnaeRepository.GetByDescricao(TipoAtividadeCnaeDefaultValuesAccess.GetValue(TipoAtividadeCnaeDefaultValues.AtividadeSecundaria));
// Atividade Principal
TipoCnae tipoCnaeDb = null;
if (responseReceita.AtividadePrincipal.Any())
{
foreach (var ap in responseReceita.AtividadePrincipal)
{
tipoCnaeDb = _empresaRepository.GetTipoCnaeByCodigo(ap.Code);
if (tipoCnaeDb == null)
{
try
{
tipoCnaeDb = new TipoCnae(ap.Text, ap.Code);
tipoCnaeDb = _empresaRepository.CreateTipoCnae(tipoCnaeDb);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar a Atividade Principal da Empresa, tente novamente mais tarde."));
}
}
AtividadeCnae atividadeCnae = null;
try
{
atividadeCnae = new AtividadeCnae(tipoCnaeDb.Id, AtividadePrincipalDb.Id, empresaDb.Id);
_empresaRepository.CreateAtividadeCnae(atividadeCnae);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao vincular o CNAE à Empresa, tente novamente mais tarde."));
}
}
}
// Atividades Secundárias
if (responseReceita.AtividadeSecundaria.Any())
{
foreach (var ats in responseReceita.AtividadeSecundaria)
{
tipoCnaeDb = _empresaRepository.GetTipoCnaeByCodigo(ats.Code);
if (tipoCnaeDb == null)
{
try
{
tipoCnaeDb = new TipoCnae(ats.Text, ats.Code);
tipoCnaeDb = _empresaRepository.CreateTipoCnae(tipoCnaeDb);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar alguma Atividade Secundária da Empresa, tente novamente mais tarde."));
}
}
AtividadeCnae atividadeCnae = null;
try
{
atividadeCnae = new AtividadeCnae(tipoCnaeDb.Id, AtividadeSecundariaDb.Id, empresaDb.Id);
_empresaRepository.CreateAtividadeCnae(atividadeCnae);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao vincular o CNAE à Empresa, tente novamente mais tarde."));
}
}
}
#endregion
// Registra todos da lista de QSA
if (responseReceita.QSA.Any())
{
foreach (var qsa in responseReceita.QSA)
{
QSA qsaDb = null;
try
{
qsaDb = new QSA(qsa.Nome, qsa.Qual, empresaDb.Id);
_empresaRepository.CreateQSA(qsaDb);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o QSA da Empresa."));
}
}
}
#endregion
}
else
{
#region Caso empresa já exista
var usuarioEmpresaDb = _usuarioEmpresaRepository.GetByEmpresaId(empresaDb.Id);
// Verifica se já existe um usuário vinculado à empresa
if (usuarioEmpresaDb != null)
{
return(StatusCode(400, $"A Empresa de CNPJ [{input.Cnpj}] já está vinculada à um usuário."));
}
#endregion
}
var tipoEmpresaDb = _tipoUsuarioRepository.GetByDescricao(TipoUsuarioDefaultValuesAccess.GetValue(TipoUsuarioDefaultValues.Empresa));
var statusUsuarioDb = _statusUsuarioRepository.GetByDescricao(StatusUsuarioDefaultValuesAcess.GetValue(StatusUsuarioDefaultValues.ContaAtiva));
// Criação do usuário
usuarioDb = null;
try
{
// Gera Hash da senha
var senhaHash = new PasswordHasher <Usuario>().HashPassword(usuarioDb, input.Senha);
usuarioDb = new Usuario(input.Nome, input.Email, senhaHash, tipoEmpresaDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o Usuário."));
}
usuarioDb = _usuarioRepository.Create(usuarioDb);
// Cria o 1° histórico do usuário
HistoricoStatusUsuario historicoUsuario = null;
try
{
historicoUsuario = new HistoricoStatusUsuario(statusUsuarioDb.Id, usuarioDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o histórico do usuário."));
}
_historicoStatusUsuarioRepository.Create(historicoUsuario);
// Criação do UsuarioEmpresa, vincula o usuário à empresa criada
UsuarioEmpresa usuarioEmpresa = null;
try
{
usuarioEmpresa = new UsuarioEmpresa(empresaDb.Id, usuarioDb.Id);
}
catch (Exception)
{
return(StatusCode(500, "Houve um erro interno ao criar o UsuarioEmpresa (vincular o usuário à empresa)."));
}
_usuarioEmpresaRepository.Create(usuarioEmpresa);
await _usuarioRepository.UnitOfWork.SaveDbChanges();
return(StatusCode(200, $"Usuário {usuarioDb.Email} com perfil de Empresa com CNPJ {empresaDb.CNPJ} criado com sucesso!"));
}
public void DadaUmaSenhaComEspacosEmBrancoOConstrutorDeveRetornarUmUsuarioInvalido()
{
UsuarioEmpresa usuario = new UsuarioEmpresa(empresa, nomeContato, email, " ", " ");
Assert.IsFalse(usuario.IsValid());
}
public static void InicializarUsuarios(TallerIVDbContext db)
{
//if (!db.Users.Any())
//{
var roleStore = new RoleStore <IdentityRole>(db);
var roleManager = new RoleManager <IdentityRole>(roleStore);
var userStore = new UserStore <IdentityUser>(db);
var userManager = new UserManager <IdentityUser>(userStore);
// Add missing roles
var role = roleManager.FindByName("Admin");
if (role == null)
{
role = new IdentityRole("Admin");
roleManager.Create(role);
}
role = roleManager.FindByName("Empleado");
if (role == null)
{
role = new IdentityRole("Empleado");
roleManager.Create(role);
}
role = roleManager.FindByName("Empresa");
if (role == null)
{
role = new IdentityRole("Empresa");
roleManager.Create(role);
}
role = roleManager.FindByName("Reclutador");
if (role == null)
{
role = new IdentityRole("Reclutador");
roleManager.Create(role);
}
#region Usuarios Empleados
var userSabaj = userManager.FindByName("*****@*****.**");
if (userSabaj == null)
{
var Empleado = new UsuarioEmpleado(DateTime.Now, "*****@*****.**", "1150437641", "*****@*****.**", "Nicolas", "Sabaj", new DateTime(1995, 9, 23), "Mi nombre es Nicolás.");
userManager.Create(Empleado, "Ns12345!");
userManager.AddToRole(Empleado.Id, "Empleado");
}
var userGoyano = userManager.FindByName("*****@*****.**");
if (userGoyano == null)
{
var Empleado = new UsuarioEmpleado(DateTime.Now, "*****@*****.**", "1163656732", "*****@*****.**", "Nicolas", "Goyano", new DateTime(1996, 6, 29), "Mi nombre es Nicolás Goyano.");
userManager.Create(Empleado, "Ng12345!");
userManager.AddToRole(Empleado.Id, "Empleado");
}
var userBangueses = userManager.FindByName("*****@*****.**");
if (userBangueses == null)
{
var Empleado = new UsuarioEmpleado(DateTime.Now, "*****@*****.**", "1153258745", "*****@*****.**", "Gonzalo", "Bangueses", new DateTime(1985, 6, 20), "Mi nombre es Gonza.");
userManager.Create(Empleado, "Gb12345!");
userManager.AddToRole(Empleado.Id, "Empleado");
}
var userFraiman = userManager.FindByName("*****@*****.**");
if (userBangueses == null)
{
var Empleado = new UsuarioEmpleado(DateTime.Now, "*****@*****.**", "1136456567", "*****@*****.**", "Brian", "Fraiman", new DateTime(1995, 5, 3), "Mi nombre es Brian.");
userManager.Create(Empleado, "Bf12345!");
userManager.AddToRole(Empleado.Id, "Empleado");
}
#endregion
#region Empresa
var Empresa = userManager.FindByName("*****@*****.**");
if (Empresa == null)
{
Empresa = new UsuarioEmpresa("1234321", "La Empresa 1", DateTime.Now, "*****@*****.**", "*****@*****.**");
userManager.Create(Empresa, "Le12345!");
userManager.AddToRole(Empresa.Id, "Empresa");
}
#endregion
var user = userManager.FindByName("*****@*****.**");
if (user == null)
{
var Reclutador = new UsuarioReclutador(DateTime.Now, "*****@*****.**", "1151235476", "*****@*****.**", "Rec1", "TE", DateTime.Now, Empresa.Id);
userManager.Create(Reclutador, "Le12345!");
userManager.AddToRole(Reclutador.Id, "Reclutador");
}
//}
}
public void AutenticadoDeveRetornarFalsoSeASenhaForNula()
{
UsuarioEmpresa usuario = new UsuarioEmpresa(empresa, nomeContato, email, senha, senha);
Assert.IsFalse(usuario.Autenticado(null));
}
public void Adicionar(UsuarioEmpresa usuario)
{
_contexto.UsuarioEmpresa.Add(usuario);
}
public void cadastrar(object sender, EventArgs e)
{
int idEmp = 0;
if (Session["sIdEmp"] == null)
{
Response.Redirect("loginEmpresa.aspx");
}
else
{
idEmp = (int)Session["sIdEmp"];
}
postLogin = login.Text;
postSenha = senha.Text;
postNome = nomCompleto.Text;
postEmail = email.Text;
postCpf = cpf.Text;
postCep = cep.Text;
postEnd = endereco.Text;
postComplemento = complemento.Text;
postNum = Int32.Parse(numero.Text);
postTel = tel.Text;
postCel = cel.Text;
postFunc = funcao.Text;
postEscolar = Int32.Parse(Escolaridade.SelectedValue);
//int cargoSelecionado = Int32.Parse(Cargo.SelectedValue);
int cargoSelecionado = -1;
if (acao.Equals("primCad"))
{
cargoSelecionado = 3;
}
else
{
cargoSelecionado = Int32.Parse(Cargo.SelectedValue);
}
string descEscolar = new Escolaridade().EscolherEscolaridade(postEscolar).Descricao;
MySqlDateTime mysqldt = new MySqlDateTime(DateTime.Now.ToString("yyyy/MM/dd hh:mm:ss"));
Cidade cidade = new CidadeDAO().selectCidadePorNome(postCidade);
Usuario user = new Usuario(0, postLogin, postSenha, postNome, postEmail, postCpf, postTel, postCel, postEnd, postNum, postComplemento,
postCep, cidade, 0, mysqldt, new MySqlDateTime(), 0, 0, 0, null);
var msg = new UsuarioDAO().insertUser(user);
user = new UsuarioDAO().selectUserLogin(postLogin);
UsuarioEmpresa userEmp = new UsuarioEmpresa(0, user.Id, idEmp, postFunc, cargoSelecionado, 0, descEscolar, formacao.Text, 0, postEscolar, 0);
if (new UsuarioEmpresaDAO().insertUserEmp(userEmp))
{
if (acao.Equals("primCad"))
{
Empresa emp = new EmpresaDAO().selectEmp(idEmp);
emp.IdTecnico = user.Id;
emp.IdDiretor = user.Id;
emp.IdComercial = user.Id;
emp.Block = 0;
new EmpresaDAO().updateEmpresa(emp);
}
if (Session["sId"] == null)
{
Response.Redirect("loginEmpresa.aspx?sit=1&msg=sucessoCadastrarEmpresa");
}
else
{
Response.Redirect("empresaColaboradores.aspx?sit=1&msg=sucessoCadastrarColaborador");
}
}
else
{
statusOperação = 2;
msg = Mensagens.ResourceManager.GetString("ErroInesperado");
}
}
public void AutenticadoDeveRetornarFalsoSeASenhaForEspacosEmBranco()
{
UsuarioEmpresa usuario = new UsuarioEmpresa(empresa, nomeContato, email, senha, senha);
Assert.IsFalse(usuario.Autenticado(" "));
}
public void ProbarAprobacionAvisos()
{
List <AptitudPorAviso> AptitudesAviso = new List <AptitudPorAviso>();
Aptitud Ap1 = new Aptitud(1, "Apt1");
Aptitud Ap2 = new Aptitud(2, "Apt2");
Aptitud Ap3 = new Aptitud(3, "Apt3");
Aptitud Ap4 = new Aptitud(4, "Apt4");
AptitudPorAviso APV1 = new AptitudPorAviso(1, 22, Ap1, Prioridad.Baja);
AptitudPorAviso APV2 = new AptitudPorAviso(2, 22, Ap2, Prioridad.Normal);
AptitudPorAviso APV3 = new AptitudPorAviso(3, 22, Ap3, Prioridad.Excluyente);
AptitudPorAviso APV4 = new AptitudPorAviso(4, 22, Ap4, Prioridad.Normal);
AptitudesAviso.Add(APV1);
AptitudesAviso.Add(APV2);
AptitudesAviso.Add(APV3);
AptitudesAviso.Add(APV4);
List <Aptitud> AptitudesPostulante = new List <Aptitud>();
AptitudesPostulante.Add(Ap2);
AptitudesPostulante.Add(Ap3);
List <Aptitud> ListaPrueba = new List <Aptitud>();
Aptitud ApPrueba = new Aptitud(10, "Prueba");
ListaPrueba.Add(ApPrueba);
ListaPrueba.Add(Ap1);
UsuarioEmpresa UE = new UsuarioEmpresa("3066552214", "Razon Social", DateTime.Now, "*****@*****.**", "*****@*****.**");
UsuarioReclutador UR = new UsuarioReclutador(DateTime.Now, "*****@*****.**", "", "*****@*****.**", "GG", "dsad", DateTime.Now, "dsa");
List <Aviso> Avisos = new List <Aviso>();
for (int i = 0; i < 5; i++)
{
if (i > 2)
{
Aviso a = new Aviso("Titulo" + i, "Desc" + i, DateTime.Now, UR, AptitudesAviso, 1000, Prioridad.Baja, TipoRelacionDeTrabajo.Dependencia, TallerIV.Dominio.Usuarios.Prioridad.Normal, 4, TallerIV.Dominio.Usuarios.Prioridad.Normal, "dsasa", "DS");
Avisos.Add(a);
}
else
{
Aviso a = new Aviso("Titulo" + i, "Desc" + i, DateTime.Now, UR, AptitudesAviso, 1000, Prioridad.Baja, TipoRelacionDeTrabajo.Dependencia, TallerIV.Dominio.Usuarios.Prioridad.Normal, 4, TallerIV.Dominio.Usuarios.Prioridad.Normal, "dsasa", "DS");
Avisos.Add(a);
}
}
List <UsuarioEmpleado> Empleados = new List <UsuarioEmpleado>();
for (int i = 0; i < 5; i++)
{
if (i == 2)
{
UsuarioEmpleado UEmp = new UsuarioEmpleado(DateTime.Now, "*****@*****.**", "", "AA" + i, "dd", "asa", DateTime.Now, "SA", AptitudesPostulante);
Empleados.Add(UEmp);
}
else
{
UsuarioEmpleado UEmp = new UsuarioEmpleado(DateTime.Now, "*****@*****.**", "", "AA" + i, "dd", "asa", DateTime.Now, "SA", ListaPrueba);
Empleados.Add(UEmp);
}
}
GeneradorCoincidencias GC = new GeneradorCoincidencias();
List <Coincidencia> ListaCoincidencias = new List <Coincidencia>();
ListaCoincidencias = GC.GenerarListadoCoincidencias(Avisos[3], Empleados);
if (ListaCoincidencias != null)
{
Console.WriteLine("dsadasda");
}
}
protected void Page_Load(object sender, EventArgs e)
{
UsuarioEmpresa usr = (UsuarioEmpresa)Session["Usuario"];
lblMensaje.Text = "Bienvenido al panel de Usuarios Empleados - " + usr.Nombre;
}
