public async Task <JsonResult> AjaxDelete(string id)
{
try
{
ApplicationUser user = await UserManager.FindByNameAsync(id).ConfigureAwait(false);
if (user == null)
{
throw new HttpException(404, "Not found");
}
IdentityResult result = await UserManager.DeleteAsync(user).ConfigureAwait(false);
if (!result.Succeeded)
{
throw new InvalidOperationException(result.Errors.FirstOrDefault());
}
var userInfo = new BackOfficeUserInfo();
return(Json(new AjaxGenericResultModel
{
Success = true,
Message = Resources.CommonStrings.RegisterDeletedSuccessMessage
}, JsonRequestBehavior.DenyGet));
}
catch
{
return(Json(new AjaxGenericResultModel
{
Success = false,
Message = "O usuário já realizou ações no sistema e não pode ser excluído. Utilize a opção \"Inativar\" na tela de edição."
}, JsonRequestBehavior.DenyGet));
}
}
public async Task <ActionResult> Edit(BOGroupCreateViewModel model)
{
IEnumerable <string> selectedPermissions = model.PermissionGroups
.SelectMany(x => x.Permissions.Where(y => y.IsSelected)).Select(x => x.Name);
if (!ModelState.IsValid)
{
model.PermissionGroups = Mapper.Map <List <PermissionGroupViewModel> >(PermissionManager.Groups);
model.SetSelectedPermissions(selectedPermissions);
return(View(model));
}
ApplicationRole role = await RoleManager.FindByIdAsync(model.Id);
if (role == null)
{
throw new HttpException(404, "Not found");
}
ApplicationRole existingRoleByName = await RoleManager.FindByNameAsync(model.Name);
if (existingRoleByName != null && existingRoleByName.Id != model.Id)
{
ModelState.AddModelError(nameof(model.Name), Res.GroupAlreadyExistsMessage);
model.PermissionGroups = Mapper.Map <List <PermissionGroupViewModel> >(PermissionManager.Groups);
model.SetSelectedPermissions(selectedPermissions);
return(View(model));
}
ApplicationRole oldRole = Mapper.Map <ApplicationRole>(role);
role.Name = model.Name;
IdentityResult result = await RoleManager.UpdateAsync(role, selectedPermissions);
if (!result.Succeeded)
{
throw new Exception(result.Errors.FirstOrDefault());
}
var userInfo = new BackOfficeUserInfo();
Notify.Success(Resources.CommonStrings.RegisterEditedSuccessMessage);
return(RedirectToAction("Index"));
}
public JsonResult TermoResponsabilidade(BOImprimirTermoResponsabilidadeViewModel viewModel)
{
try
{
ValidateModel(viewModel);
var userInfo = new BackOfficeUserInfo();
var userLog = new UserLog
{
IP = userInfo.IP,
UserId = IdUsuario
};
var request = new TermoResponsabilidadeRequest
{
IdQuarentena = viewModel.IdQuarentena,
IdImpressora = viewModel.IdImpressora,
NomeUsuario = _uow.PerfilUsuarioRepository.GetByUserId(User.Identity.GetUserId())?.Nome,
UserLog = userLog
};
_quarentenaService.ImprimirTermoResponsabilidade(request);
return(Json(new AjaxGenericResultModel
{
Success = true,
Message = "Impressão enviada com sucesso."
}, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
return(Json(new AjaxGenericResultModel
{
Success = false,
Message = "Ocorreu um erro na impressão."
}, JsonRequestBehavior.AllowGet));
}
}
public async Task <JsonResult> AjaxResetPassword(string id)
{
try
{
ApplicationUser user = await UserManager.FindByNameAsync(id).ConfigureAwait(false);
if (user == null)
{
throw new HttpException(404, "Not found");
}
ApplicationUser oldUser = Mapper.Map <ApplicationUser>(user);
string randomPassword = _passwordService.GenerateRandomPassword();
string resetToken = await UserManager.GeneratePasswordResetTokenAsync(user.Id).ConfigureAwait(false);
IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, resetToken, randomPassword).ConfigureAwait(false);
if (!result.Succeeded)
{
throw new InvalidOperationException(Resources.CommonStrings.RequestUnexpectedErrorMessage);
}
var userInfo = new BackOfficeUserInfo();
return(Json(new AjaxGenericResultModel
{
Success = true,
Message = string.Format(Res.UserPasswordResetSuccessMessage, user.UserName, randomPassword)
}, JsonRequestBehavior.DenyGet));
}
catch
{
return(Json(new AjaxGenericResultModel
{
Success = false,
Message = Res.UserPasswordResetErrorMessage
}, JsonRequestBehavior.DenyGet));
}
}
public async Task <ActionResult> Create(BOGroupCreateViewModel model)
{
Func <ViewResult> errorView = () =>
{
model.PermissionGroups = Mapper.Map <List <PermissionGroupViewModel> >(PermissionManager.Groups);
return(View(model));
};
if (!ModelState.IsValid)
{
return(errorView());
}
ApplicationRole existingRole = await RoleManager.FindByNameAsync(model.Name);
if (existingRole != null)
{
ModelState.AddModelError(nameof(model.Name), Res.GroupAlreadyExistsMessage);
return(errorView());
}
var role = Mapper.Map <ApplicationRole>(model);
IEnumerable <string> permissions = model.PermissionGroups
.SelectMany(x => x.Permissions.Where(y => y.IsSelected)).Select(x => x.Name);
IdentityResult result = await RoleManager.CreateAsync(role, permissions, IdEmpresa, IdUsuario);
if (!result.Succeeded)
{
throw new Exception(result.Errors.FirstOrDefault());
}
var userInfo = new BackOfficeUserInfo();
Notify.Success(Resources.CommonStrings.RegisterCreatedSuccessMessage);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Edit(BOAccountEditViewModel 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);
}
ViewResult errorView()
{
return(View(model));
}
if (!ModelState.IsValid)
{
return(errorView());
}
ApplicationUser user = await UserManager.FindByNameAsync(model.UserName).ConfigureAwait(false);
if (user == null)
{
throw new HttpException(404, "Not found");
}
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.");
return(errorView());
}
var existingUserByEmail = await UserManager.FindByEmailAsync(model.Email).ConfigureAwait(false);
if (existingUserByEmail != null && existingUserByEmail.Id != user.Id)
{
ModelState.AddModelError(nameof(model.Email), Res.UserEmailAlreadyExistsMessage);
return(errorView());
}
if (model.EmpresasGrupos.NullOrEmpty())
{
ModelState.AddModelError(nameof(model.EmpresasGrupos), Res.RequiredOnlyCompany);
return(errorView());
}
if (!model.EmpresasGrupos.All(w => w.Grupos.Any(a => a.IsSelected)))
{
ModelState.AddModelError(nameof(model.EmpresasGrupos), Res.RequiredOnlyGroup);
return(errorView());
}
if (!model.EmpresasGrupos.Any(w => w.IsEmpresaPrincipal))
{
ModelState.AddModelError(nameof(model.EmpresasGrupos), "Selecione a empresa principal do usuário.");
return(errorView());
}
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());
}
ApplicationUser oldUser = Mapper.Map <ApplicationUser>(user);
user.Email = model.Email;
var empresasGruposNew = new StringBuilder();
var empresasGruposOld = new StringBuilder();
var companiesUser = _unitOfWork.UsuarioEmpresaRepository.GetAllEmpresasByUserId(user.Id);
var empresas = Empresas.Where(w => companiesUser.Contains(w.IdEmpresa)).ToList();
foreach (var empresa in empresas)
{
IList <string> selectedRoles = await UserManager.GetUserRolesByIdEmpresa(user.Id, empresa.IdEmpresa).ConfigureAwait(false);
if (selectedRoles.Any())
{
empresasGruposOld.AppendLine(string.Format("{0}: {1}", empresa.Nome, string.Join(", ", selectedRoles.ToArray())));
empresasGruposOld.AppendLine(" || ");
}
}
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);
IList <string> rolesUsuarioEdicao = await UserManager.GetUserRolesByIdEmpresa(user.Id, item.IdEmpresa).ConfigureAwait(false);
IList <string> rolesUsuarioLogado = await UserManager.GetUserRolesByIdEmpresa(User.Identity.GetUserId(), item.IdEmpresa).ConfigureAwait(false);
IEnumerable <string> rolesIgnorar = rolesUsuarioEdicao.Where(x => !rolesUsuarioLogado.Any(y => y == x) && !rolesUsuarioLogado.Contains("Administrador"));
empresasGruposNew.AppendLine(string.Format("{0}: {1}", item.Nome, string.Join(", ", selectedRoles.ToArray())));
empresasGruposNew.AppendLine(" || ");
IdentityResult result = await UserManager.UpdateAsync(user, selectedRoles, rolesIgnorar, item.IdEmpresa).ConfigureAwait(false);
if (!result.Succeeded)
{
throw new InvalidOperationException(Resources.CommonStrings.RequestUnexpectedErrorMessage);
}
}
var oldPerfil = _unitOfWork.PerfilUsuarioRepository.GetById(model.PerfilUsuarioId);
var perfilUsuario = _unitOfWork.PerfilUsuarioRepository.GetById(model.PerfilUsuarioId);
perfilUsuario.Nome = model.Nome;
perfilUsuario.EmpresaId = model.EmpresasGrupos.Where(w => w.IsEmpresaPrincipal).First().IdEmpresa;
perfilUsuario.Departamento = model.Departamento;
perfilUsuario.DataNascimento = model.DataNascimento;
perfilUsuario.Cargo = model.Cargo;
perfilUsuario.Ativo = model.Ativo;
_boService.EditPerfilUsuario(perfilUsuario);
var empresasGrupos = model.EmpresasGrupos.Where(w => w.Grupos.Any(a => a.IsSelected))
.Select(s => new BOAccountService.UsuarioEmpresaUpdateFields {
IdEmpresa = s.IdEmpresa, IdPerfilImpressoraPadrao = s.IdPerfilImpressoraPadrao, CorredorEstoqueInicio = s.CorredorEstoqueInicio, CorredorEstoqueFim = s.CorredorEstoqueFim, CorredorSeparacaoInicio = s.CorredorSeparacaoInicio, CorredorSeparacaoFim = s.CorredorSeparacaoFim
}).ToList();
_boService.EditUsuarioEmpresas(Empresas, empresasGrupos, user.Id, perfilUsuario.PerfilUsuarioId);
var userInfo = new BackOfficeUserInfo();
Notify.Success(Resources.CommonStrings.RegisterEditedSuccessMessage);
return(RedirectToAction("Index"));
}
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"));
}
public JsonResult DetalhesQuarentena(DetalhesQuarentenaViewModel model)
{
ValidateModel(model);
string mensagemErro = null;
if (model.IdStatus == QuarentenaStatusEnum.Retirado)
{
if (string.IsNullOrEmpty(model.CodigoConfirmacao))
{
ModelState.AddModelError(nameof(model.CodigoConfirmacao), (mensagemErro = "O código de confirmação é obrigatório para retirar a mercadoria."));
}
else
{
bool existeCod = _uow.QuarentenaRepository.Any(x => x.IdQuarentena == model.IdQuarentena && x.CodigoConfirmacao == model.CodigoConfirmacao);
if (!existeCod)
{
ModelState.AddModelError(nameof(model.CodigoConfirmacao), (mensagemErro = "O código de confirmação está incorreto!"));
}
}
}
//Valida a model.
if (!ModelState.IsValid)
{
return(Json(new AjaxGenericResultModel
{
Success = false,
Message = mensagemErro ?? Resources.CommonStrings.RegisterEditedErrorMessage
}));
}
try
{
//Captura os dados para atualiza-los posteriormente.
Quarentena entidade = _uow.QuarentenaRepository.GetById(model.IdQuarentena);
//Captura os dados "antigo" para o log.
Quarentena old = new Quarentena
{
DataAbertura = entidade.DataAbertura,
DataEncerramento = entidade.DataEncerramento,
IdLote = entidade.IdLote,
IdQuarentena = entidade.IdQuarentena,
IdQuarentenaStatus = entidade.IdQuarentenaStatus,
CodigoConfirmacao = entidade.CodigoConfirmacao,
Observacao = entidade.Observacao
};
//Verifica se o status anterior era Encaminhado para Auditoria e o atual Aberto.
//Caso seja, informa o usuário que a ação não é permitida.
if (old.IdQuarentenaStatus == QuarentenaStatusEnum.EncaminhadoAuditoria && (model.IdStatus == QuarentenaStatusEnum.Aberto || model.IdStatus == QuarentenaStatusEnum.Retirado))
{
ModelState.AddModelError(nameof(model.IdStatus), (mensagemErro = "A quarentena foi encaminhada para Auditoria. Não é permitido atualizar o status para " + model.IdStatus.ToString() + "."));
return(Json(new AjaxGenericResultModel
{
Success = false,
Message = mensagemErro ?? Resources.CommonStrings.RegisterEditedErrorMessage
}));
}
//Atualiza o status e observação da quarentena.
entidade.IdQuarentenaStatus = model.IdStatus;
entidade.Observacao = model.Observacao;
//Verifica se o status é Retirado ou Finalizado.
//Caso seja, insere a data de encerramento pois, considera-se que a mercadoria foi retirada ou alguma outra ação feita (finalizado).
if (model.IdStatus == QuarentenaStatusEnum.Retirado || model.IdStatus == QuarentenaStatusEnum.Finalizado)
{
entidade.DataEncerramento = DateTime.Now;
}
_uow.QuarentenaRepository.Update(entidade, IdUsuario);
var userInfo = new BackOfficeUserInfo();
return(Json(new AjaxGenericResultModel
{
Success = true,
Message = Resources.CommonStrings.RegisterEditedSuccessMessage
}));
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
return(Json(new AjaxGenericResultModel
{
Success = false,
Message = Resources.CommonStrings.RegisterEditedErrorMessage
}));
}
}
