static void Main()
{
Criptografia cypher = new Criptografia();
string a = "test";
string b = cypher.CifraCesar(a, 18); // Ok
Console.WriteLine(a);
Console.WriteLine(b);
}
public ActionResult Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
try
{
string Token = string.Concat(model.Usuario, model.Password, model.Usuario);
string Key = Criptografia.Base64StringAHexString(Criptografia.EncriptarSha512(Token));
string Mensaje = new UsuarioBL().ValidarUsuario(model.Usuario, Key);
if (Mensaje.Equals("OK"))
{
Usuario UsuarioActual = new UsuarioBL().ObtenerxLogin(model.Usuario, true);
FormsAuthentication.SetAuthCookie(model.Usuario, true);
CustomHelper.setUsuario(model.Usuario);
CustomHelper.setColegio(UsuarioActual.Colegio);
if (!UsuarioActual.ReiniciarPassword)
{
return(RedirectToAction("Dashboard", "Inicio"));
}
else
{
return(RedirectToAction("ReiniciarPassword", new { id = UsuarioActual.UsuarioId }));
}
}
}
catch (Exception ex)
{
ViewBag.Error = string.Format("Message: {0} StackTrace: {1}", ex.Message, ex.StackTrace);
return(View("~/Views/Shared/Error.cshtml"));
}
}
ModelState.AddModelError("", "El usuario o la clave son incorrectos.");
return(View(model));
}
public ActionResult Alterar(UsuarioModelAlterarSenha model)
{
try
{
if (ModelState.IsValid)
{
if (usuarioDal.VerificarSenhaAtual(Criptografia.Encriptar(model.SenhaAtual), model.IdUsuario))
{
if (model.Senha.Equals(model.SenhaConf))
{
Usuario u = new Usuario();
u.IdUsuario = model.IdUsuario;
u.Senha = Criptografia.Encriptar(model.Senha);
usuarioDal.Salvar(u);
TempData["Mensagem"] = model.Email + ", Alterado(a) com sucesso!";
return(RedirectToAction("index", "veiculos"));
}
else
{
TempData["Mensagem"] = "As senhas não conferem!";
return(RedirectToAction("alterar"));
}
}
else
{
TempData["Mensagem"] = "A Senha atual está incorreta.";
return(RedirectToAction("alterar"));
}
}
}
catch (Exception)
{
throw;
}
return(View("Alterar"));
}
public ActionResult Index(UsuarioLoginModel model)
{
if (ModelState.IsValid)
{
try
{
Criptografia c = new Criptografia();
UsuarioRepositorio rep = new UsuarioRepositorio();
Usuario u = rep.FindByLoginSenha(model.Login, c.EncriptarSenha(model.Senha));
if (u != null)
{
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(u.Login, false, 5);
HttpCookie cookie = new HttpCookie(FormsAuthentication.FormsCookieName, FormsAuthentication.Encrypt(ticket));
Response.Cookies.Add(cookie);
Session["usuario"] = u;
return(RedirectToAction("Index", "Logged"));
}
else
{
ViewBag.Mensagem = "Acesso Negado.";
}
}
catch (Exception e)
{
ViewBag.Mensagem = e.Message;
}
}
return(View());
}
public ActionResult Login(LoginViewModel loginViewModel, string returnUrl)
{
if (ModelState.IsValid)
{
try
{
using (UnitOfWork.UnitOfWork uow = new UnitOfWork.UnitOfWork())
{
Usuario usuario = new Usuario();
usuario.Login = loginViewModel.Login;
usuario.Senha = loginViewModel.Senha;
usuario.Senha = Criptografia.Encrypt(usuario.Senha);
var usuarioLogado = uow.UsuarioRepositorio.Get(x => x.Login == usuario.Login && x.Senha == usuario.Senha);
if (usuarioLogado != null)
{
Session.Add("usuario", usuarioLogado.Nome);
Session.Add("id_usuario", usuarioLogado.Id);
FormsAuthentication.SetAuthCookie(usuario.Login, false);
if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/") &&
returnUrl.StartsWith("//") && returnUrl.StartsWith("/\\"))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Index", "Home", null));
}
else
{
ModelState.AddModelError("", "Senha ou Usuário Incorreto!");
}
}
}
catch (Exception ex)
{
ModelState.AddModelError("", string.Format("Ocorreu um erro ao Efetuar o login !\n {0}", ex.Message));
}
}
return(View(loginViewModel));
}
public bool AlterarSenha(AlteraSenha model)
{
var id = _tokenService.GetIdByToken();
var usuario = _unitOfWork.UsuarioRepository.Get(id);
if (usuario != null)
{
var token = _tokenService.GetToken();
if (usuario.TokenAlterarSenha == token)
{
if (model.Password == model.ConfirmPassword)
{
usuario.Password = Criptografia.SenhaCriptografada(model.Password);
usuario.TokenAlterarSenha = null;
_unitOfWork.UsuarioRepository.Atualizar(usuario);
_unitOfWork.Commit();
return(true);
}
else
{
throw new Exception("Senha inválida");
}
}
else
{
throw new Exception("Token inválido");
}
}
else
{
throw new AppException("Usuário não encontrado");
}
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
if (!IsPostBack)
{
if (Request.QueryString.HasKeys())
{
if (Request.QueryString["id"] != null && !string.IsNullOrEmpty(Page.Request.QueryString["id"]))
{
var id = Request.QueryString["id"];
id = Criptografia.Decrypt(id.Replace('_', '+'));
Session["idEpi"] = id;
if (!id.Equals("0"))
{
//Editar EPI
CarregaDdlTipoMaterial(false);
CarregaDadosEpi(int.Parse(id));
lblCabecalho.Text = "Editar EPI";
pnlStatus.Visible = true;
}
else
{
//Cadastro de EPI
pnlStatus.Visible = false;
CarregaDdlTipoMaterial(true);
}
}
}
}
}
catch (Exception ex)
{
ltlMsn.Text = "<div class=\"alert alert-block alert-danger fade in\"><button data-dismiss=\"alert\" class=\"close\" type=\"button\">X" +
"</button><p><i class=\"fa fa-times-circle fa-lg\"></i>Page_Load-ERRO:" + ex.Message + "</p></div>";
}
}
private void btnEntrar_Click(object sender, EventArgs e)
{
if (string.IsNullOrWhiteSpace(txtUsuario.Text) || string.IsNullOrWhiteSpace(txtSenha.Text))
{
MessageBox.Show("Informe o login e a senha.");
}
else
{
try
{
Funcionario funcionario = new Funcionario();
Criptografia criptografia = new Criptografia();
funcionario.Email = txtUsuario.Text;
string cifra = criptografia.Cifrar(txtSenha.Text);
funcionario.Senha = criptografia.Cifrar(txtSenha.Text);
if (new BLL.FuncionarioBLL().isNull(funcionario))
{
MessageBox.Show("O login foi realizado com sucesso.");
this.Name = "form";
Form form = this;
form.Hide();
frmBase frm = new frmBase();
frm.ShowDialog();
this.Visible = true;
}
else
{
MessageBox.Show("Erro! Verifique o seu email e senha.");
}
}
catch (Exception ex)
{
MessageBox.Show("Erro. " + ex.Message);
}
}
}
public IActionResult Index(LoginViewModel loginViewModel)
{
if (!ModelState.IsValid)
{
return(View(loginViewModel));
}
else
{
try
{
MD5 Md5Hash = MD5.Create();
var senhaMD5 = Criptografia.GetMd5Hash(Md5Hash, loginViewModel.Senha);
var usuario = mContext.Usuario.Where(x => x.Email == loginViewModel.Email && x.Senha == senhaMD5).FirstOrDefault();
if (usuario == null)
{
ViewData["ErroLogin"] = "******";
return(View(loginViewModel));
}
else
{
//Manter os dados do usuário em sessão
HttpContextAccessor.HttpContext.Session.SetString(Sessao.NOME_USUARIO, usuario.Nome);
HttpContextAccessor.HttpContext.Session.SetString(Sessao.EMAIL_USUARIO, usuario.Email);
HttpContextAccessor.HttpContext.Session.SetInt32(Sessao.CODIGO_USUARIO, (int)usuario.Codigo);
HttpContextAccessor.HttpContext.Session.SetInt32(Sessao.LOGADO, 1);
return(RedirectToAction("Index", "Home"));
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
}
public ActionResult Sair()
{
try
{
string id = string.Empty;
try
{
id = Criptografia.Descriptografar(base.Session["IDUsuario"].ToString());
}
catch { }
if (!string.IsNullOrEmpty(id))
{
base.Session.RemoveAll();
base.Session.Clear();
base.Session.Abandon();
base.Session["IDUsuario"] = string.Empty;
using (var db = new nosso_showEntities(Conexao.GetString()))
{
int idUsuario = int.Parse(Criptografia.Descriptografar(id));
var auths = db.autenticacao.Where(x => x.IDUsuario == idUsuario && x.Sessao == Session.SessionID).ToList();
for (int i = 0; i < auths.Count; i++)
{
db.autenticacao.DeleteObject(auths[i]);
}
db.SaveChanges();
}
}
}
catch { }
return(Redirect("/inicio/"));
}
private void LoadParameters()
{
this.objLog.GravarLog(Log.TypeMessage.Center, "Loading Parameters");
this.objLog.GravarLog(Log.TypeMessage.ThinLine, "");
this.objLog.GravarLog("LogPath", this.sLogPath, false);
try
{
tParameter.tParameterTable table = Parameter.getAll("SERVICE_CRI_");
this.tsTimeTransfer = Parameter.getTime("SERVICE_CRI_TRANSFER_TIME", table);
this.objLog.GravarLog("TimeTransfer", this.tsTimeTransfer.ToString(), false);
this.sFilesPath = Parameter.getString("SERVICE_CRI_FILE_PATH", table);
this.objLog.GravarLog("FilesPath", this.sFilesPath, false);
this.sFTP_A = Parameter.getString("SERVICE_CRI_FTP_A", table);
this.objLog.GravarLog("FTP_A", this.sFTP_A, false);
this.sFTP_B = Parameter.getString("SERVICE_CRI_FTP_B", table);
this.objLog.GravarLog("FTP_B", this.sFTP_B, false);
this.sFTP_User = Parameter.getString("SERVICE_CRI_FTP_USER", table);
this.objLog.GravarLog("FTP_User", this.sFTP_User, false);
this.sFTP_Pass = Parameter.getString("SERVICE_CRI_FTP_PASSWORD", table);
this.objLog.GravarLog("FTP_Pass", this.sFTP_Pass, false);
this.sFTP_Pass = Criptografia.Descriptografar(this.sFTP_Pass);
this.sFTP_Backup = Parameter.getBool("SERVICE_CRI_BACKUP_OTHER_FILES", table);
this.objLog.GravarLog("FTP_Backup", this.sFTP_Backup.ToString(), false);
}
catch (Exception ex)
{
this.objLog.GravarLog(Log.TypeMessage.Error, ex.Message + " | " + ex.StackTrace);
}
}
public bool ValidaUsuario(string email, string senha)
{
bool validado;
try
{
UsuarioAcessoADados usuarioAcessoADados = new UsuarioAcessoADados(); //instanciando a classe para utilizar o método Usuario
Usuario usuario = usuarioAcessoADados.ObterUsuario(email); //criando uma variável do tipo Usuário e passando o email para o UsuárioAcessoADados
Criptografia criptografia = new Criptografia(); //instanciando a classe
//senhaCriptografada = criptografia.CriptografarSenha(senha);
validado = criptografia.VerificarSenha(senha, usuario.Senha); //validando a criptografia pegando a senha digitada e comparando com a senha salva no banco de dados.
return(true);
}
catch (Exception)
{
throw;
}
}
public ActionResult Editar([Bind(Include = "id_usuario,login_usuario,senha,pessoa_id_pessoa")] usuario usuario)
{
if (ModelState.IsValid)
{
db.Entry(usuario).State = EntityState.Modified;
usuario us = db.usuario.Find(usuario.id_usuario);
if (!us.senha.Equals(usuario.senha))
{
usuario.senha = Criptografia.Codifica(usuario.senha);
}
else
{
usuario.senha = us.senha;
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.pessoa_id_pessoa = new SelectList(db.pessoa, "id_pessoa", "nome", usuario.pessoa_id_pessoa);
return(View(usuario));
}
public UsuarioLogin Login(string email, string password)
{
var usuario = _unitOfWork.UsuarioRepository.GetByEmail(email);
if (usuario == null)
{
throw new AppException("Usuário não encontrado");
}
else if (usuario.Password != Criptografia.SenhaCriptografada(password))
{
throw new AppException("Senha inválida");
}
usuario.Token = _tokenService.GenerateToken(usuario);
_unitOfWork.UsuarioRepository.Atualizar(usuario);
_unitOfWork.Commit();
var usuarioLogin = _mapper.Map <UsuarioLogin>(usuario);
return(usuarioLogin);
}
public void MudarSenha(MudarSenhaDTO mudarSenhaDTO)
{
UsuarioRecuperacaoSenha usuarioRecuperacaoSenha = new UsuarioRecuperacaoSenha();
try
{
using (var db = new PortifolioContext())
{
usuarioRecuperacaoSenha = db.UsuarioRecuperacaoSenha.FirstOrDefault(x => x.Cpf == mudarSenhaDTO.Cpf && x.EmailHash == mudarSenhaDTO.Key && x.DataExpiracao > DateTime.Now);
if (usuarioRecuperacaoSenha != null)
{
Usuario usuario = db.Usuario.FirstOrDefault(x => x.Cpf == usuarioRecuperacaoSenha.Cpf);
usuario.Senha = Criptografia.CalculaHash(mudarSenhaDTO.Senha);
db.SaveChanges();
}
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public string SaveLifeTimeRecuperaSenha(string email)
{
try
{
using (var db = new PortifolioContext())
{
var r = db.Usuario.FirstOrDefault(x => x.Email == email);
UsuarioRecuperacaoSenha usuarioRecuperaSenha = new UsuarioRecuperacaoSenha();
usuarioRecuperaSenha.Cpf = r.Cpf;
usuarioRecuperaSenha.EmailHash = Criptografia.CalculaHash(email);
usuarioRecuperaSenha.DataExpiracao = DateTime.Now.AddHours(24);
db.UsuarioRecuperacaoSenha.Add(usuarioRecuperaSenha);
db.SaveChanges();
return(usuarioRecuperaSenha.EmailHash);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ActionResult Logar([Bind(Include = "Id,Login,Senha")] Logar usuario)
{
if (ModelState.IsValid)
{
ConexaoSql bd = new ConexaoSql();
MySqlConnection conexao = bd.conexaobd();
Criptografia crip = new Criptografia();
MySqlCommand comando = new MySqlCommand("SELECT * from usuario where Login = @Login and Senha = @Senha", conexao);
comando.Parameters.AddWithValue("@Login", usuario.Login);
comando.Parameters.AddWithValue("@Senha", crip.GerarMD5(usuario.Senha));
conexao.Open();
MySqlDataReader leitor = comando.ExecuteReader();
if (leitor.HasRows) //siginifica que login e senha digitados iguais aos do BD {
{
FormsAuthentication.SetAuthCookie(usuario.Login, false);
leitor.Close();
return(RedirectToAction("Home", "Home"));
}
}
return(View(usuario));
}
public bool AlterarSenha(string email, string senha)
{
var usuario = AcessoNegocio.ObterUsuario(UsuarioSet, email.ToLower());
if (usuario != null)
{
usuario.ExpiracaoToken = DateTime.Now;
usuario.Senha = Criptografia.Encrypt(senha.ToLower());
usuario.DataOperacao = DateTime.Now;
usuario.NaturezaOperacao = ENaturezaOperacao.A.ToString();
usuario.UsuarioOperacao = usuario.UsuarioId;
UsuarioSet.Atualizar(usuario);
UnitOfWork.SalvarAlteracoes();
return(true);
}
else
{
AdicionarMensagem(ETipoMensagem.ErroValidacao, "Usuário não encontrado");
return(false);
}
}
public IActionResult Update(long id, [FromBody] Usuario usuario)
{
var criptografia = new Criptografia(key);
if (usuario == null)
{
return(NotFound());
}
if (usuario.Id != id || !valida.Email(usuario.Email))
{
return(BadRequest());
}
var _usuario = _usuarioRepositorio.Find(id);
_usuario.Nome = usuario.Nome.ToUpper();
_usuario.Email = usuario.Email;
_usuario.Senha = criptografia.Criptografar(usuario.Senha);
_usuarioRepositorio.Update(_usuario);
return(new NoContentResult());
}
private static usuario GetUsuario(string email, string senha)
{
try
{
using (var db = new nosso_showEntities(Conexao.GetString()))
{
if (!string.IsNullOrEmpty(email) && !string.IsNullOrEmpty(senha))
{
var u = new usuario();
u = db.usuario.Single(x => x.Email == email || x.Username == email.Replace("@", string.Empty));
if (Criptografia.ValidarHash128(senha, u.Hash128))
{
return(u);
}
}
}
}
catch { }
return(null);
}
public static Usuario Autenticar(string matricula, string senha)
{
if (!Sistema.UsuarioAtivo.Keys.Contains(matricula))
{
Usuario usuario = ListarPorMatricula(matricula);
if (usuario != null && Criptografia.ChecarSenha(senha, usuario.Senha))
{
return(usuario);
}
}
else if (HttpContextManager.Current.Request.Cookies.AllKeys.Contains("SIAC_Login"))
{
if (Criptografia.Base64Decode(HttpContextManager.Current.Request.Cookies["SIAC_Login"].Value).ToLower() == matricula.ToLower())
{
Usuario usuario = ListarPorMatricula(matricula);
if (usuario != null && Criptografia.ChecarSenha(senha, usuario.Senha))
{
return(usuario);
}
}
}
return(null);
}
public bool AlterarSenha(Usuario usuario, string novaSenha, int AlterouSenha)
{
try
{
using (SqlConnection con = new SqlConnection(stringConexao))
{
string query = "UPDATE Usuarios SET Senha = @Senha, AlterouSenha = @AlterouSenha WHERE IdUsuario = @IdUsuario";
con.Execute(query, new
{
Senha = Criptografia.Encriptar(novaSenha),
AlterouSenha = AlterouSenha,
IdUsuario = usuario.IdUsuario
});
}
return(true);
}
catch (Exception e)
{
return(false);
}
}
public UsuarioInfo ToUsuarioInfo()
{
UsuarioInfo lRetorno = new UsuarioInfo();
lRetorno.CodigosFilhoAssessor = this.CodAssessorAssociado;
lRetorno.Nome = this.Nome;
lRetorno.Email = this.Email;
lRetorno.CodigoUsuario = this.Id;
lRetorno.Senha = Criptografia.CalculateMD5Hash(this.Senha);
int lCodAssessor = -1;
if (int.TryParse(this.CodAssessor, out lCodAssessor))
{
lRetorno.CodigoAssessor = lCodAssessor;
}
int lTipoAcesso = -1;
if (int.TryParse(this.TipoAcesso, out lTipoAcesso))
{
lRetorno.CodigoTipoAcesso = lTipoAcesso;
}
return(lRetorno);
}
public static string EnviarEmailCadastroNovoUsuario(Account account)
{
try
{
MailMessage objEmail = new MailMessage();
objEmail.From = new MailAddress("*****@*****.**");
//objEmail.ReplyTo = "";
objEmail.To.Add(account.Email);
//objEmail.Bcc.Add("Email oculto");
objEmail.Priority = MailPriority.Normal;
objEmail.IsBodyHtml = false;
objEmail.Subject = "Meu Financeiro - Cadastro realizado com sucesso";
objEmail.Body = "Estamos muito felizes por saber que você fez seu cadastro na plataforma Meu Financeiro. Qualquer problema ou sugestão por favor entre em contato conosco. \n\n" +
"Nome: " + account.Nome + "\n" +
"Telefone: " + account.Telefone + "\n" +
"E-mail: " + account.Email + "\n" +
"Senha: " + Criptografia.Descriptografar(account.Senha) + "\n" +
"Link de Acesso: " + "http://oeconomista.azurewebsites.net/" + "\n" +
"\n\n\n" +
"Atenciosamente: " + "\n" +
"Equipe Meu Financeiro" + "\n" +
"WhatsApp: (11) 9 7951-0575";
objEmail.SubjectEncoding = Encoding.GetEncoding("ISO-8859-1");
objEmail.BodyEncoding = Encoding.GetEncoding("ISO-8859-1");
SmtpClient objSmtp = new SmtpClient();
objSmtp.Host = "smtp.gmail.com";
objSmtp.EnableSsl = true;
objSmtp.Port = 587;
objSmtp.Credentials = new NetworkCredential(_emailConfig.EmailOrigem, _emailConfig.EmailSenhaOrigem);
objSmtp.Send(objEmail);
}
catch
{
return(null);
}
return("Usuário criado com sucesso... Todos os dados foram enviados para seu e-mail: " + account.Email);
}
/// ************************************************************************************
/// Nombre : Desencriptar
/// Descripción : Metodo que encriptara texto.
/// Parámetros : Texto_Encriptado, texto que se desencriptara
/// Usuario Creo :
/// Fecha Creó :
/// Usuario Modifico:
/// Fecha Modifico :
/// ***********************************************************************************
public static string Desencriptar(string Texto_Encriptado)
{
TripleDESCryptoServiceProvider Desencriptador = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider Hash_Md5 = new MD5CryptoServiceProvider(); //se llama a las clases que tienen los algoritmos de encriptación se le aplica hashing
ICryptoTransform Criptografia;
String Texto = "";
byte[] Arreglo_Llave;// convierte el texto en una secuencia de bytes
byte[] Arragle_A_Descifrar;
byte[] Arreglo_Resultante;
try
{
Arragle_A_Descifrar = Convert.FromBase64String(Texto_Encriptado);
//algoritmo MD5
Arreglo_Llave = Hash_Md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
Hash_Md5.Clear();
Desencriptador.Key = Arreglo_Llave;
Desencriptador.Mode = CipherMode.ECB;
Desencriptador.Padding = PaddingMode.PKCS7;
Criptografia = Desencriptador.CreateDecryptor();
Arreglo_Resultante = Criptografia.TransformFinalBlock(Arragle_A_Descifrar, 0, Arragle_A_Descifrar.Length);
Desencriptador.Clear();
//se regresa en forma de cadena
Texto = UTF8Encoding.UTF8.GetString(Arreglo_Resultante);
}
catch (Exception Ex)
{
Texto = Texto_Encriptado;
throw new Exception(Ex.ToString());
}
return Texto;
}// fin de la funcion Desencriptar()
public static GuardianEmail CarregarConfiguracoes()
{
GuardianEmail email = new GuardianEmail();
string query =
" SELECT TOP 1 HOST, PORTA, SSL, LOGIN, SENHA, EMAIL, EMAIL_VALIDACAO " +
" FROM " + Tabelas_Portal.ConfigEmail + " ";
using (SqlConnection connection = new SqlConnection(ConexaoGestor.Conexao()))
{
using (SqlCommand command = new SqlCommand(query, connection))
{
connection.Open();
using (SqlDataReader reader = command.ExecuteReader())
{
if (reader.Read())
{
email.Servidor = reader["HOST"].ToString().Trim();
email.Porta = int.Parse(reader["PORTA"].ToString().Trim());
if (reader["SSL"].ToString().Trim().Equals("S"))
{
email.Ssl = true;
}
else
{
email.Ssl = false;
}
email.Login = reader["LOGIN"].ToString().Trim();
email.Senha = Criptografia.Descriptografar(reader["SENHA"].ToString().Trim());
email.EmailRemetente = reader["EMAIL"].ToString().Trim();
}
}
}
}
return(email);
}
public JsonResult Cadastrar(FuncionarioModelCadastro model)
{
try
{
FuncionarioDal d = new FuncionarioDal();
if (ModelState.IsValid)
{
if (!d.HasLogin(model.Login))
{
Funcionario f = new Funcionario();
f.Nome = model.Nome;
f.Sobrenome = model.Sobrenome;
f.Login = model.Login;
f.Senha = Criptografia.GetMD5Hash(model.Senha);
f.DataCadastro = DateTime.Now;
d.SaveOrUpdate(f);
return(Json("Funcionário cadastrado com sucesso."));
}
else
{
return(Json("Login indisponivel, tente outro."));
}
}
else
{
return(Json("Preencha os campos corretamente."));
}
}
catch (Exception e)
{
return(Json(e.Message));
}
}
public bool SaveChanges()
{
try
{
using (var db = new nosso_showEntities(Conexao.GetString()))
{
var data = DateTime.Now;
var u = new usuario
{
Ativo = true,
Confirmado = false,
Teste = false,
Cadastro = data,
Email = this.Email,
Username = this.Usuario,
Nascimento = DateTime.MinValue,
Nome = this.Nome,
Hash128 = Criptografia.GetHash128(this.Senha),
Telefone = string.Empty,
Tipo = db.usuario_tipo.First(x => x.ID == this.Tipo).ID
};
u.Senha = u.Hash128;
db.usuario.AddObject(u);
db.SaveChanges();
var req = new Requisicao(u, 2);
req.SaveChanges();
return(true);
}
}
catch { return(false); }
}
public ActionResult CadastrarDependente(DadoDependente oDependente, string IDFuncionario)
{
ViewBag.DP_Parentesco = new SelectList(Parentescos(), "Valor", "Nome");
ViewBag.IDFuncionario = IDFuncionario;
int IDDescriptografado = Convert.ToInt32(Criptografia.DecriptQueryString(IDFuncionario));
if (Convert.ToBoolean(Session["Avaliativa"]))
{
if (_Control.LimiteDependentesEmpresaAvaliativa(Convert.ToInt32(Session["IDEmpresa"])))
{
ModelState.AddModelError("Limite", "O limite de dependentes nessa Empresa Avaliativa foi atingido. (Limite de Dependentes = 5)");
}
}
if (oDependente.DP_Parentesco == "Pai" || oDependente.DP_Parentesco == "Mãe")
{
if (_Control.VerificarParentesco(IDDescriptografado, oDependente.DP_Parentesco))
{
ModelState.AddModelError("DP_Parentesco", "Este usuário já possui um dependente o grau de parentesco '" + oDependente.DP_Parentesco + "'");
return(View());
}
}
if (ModelState.IsValid)
{
Empresa aEmpresa = _Control.SelecionarEmpresa(Convert.ToInt32(Session["IDEmpresa"]));
oDependente.DP_Pessoa_Pes_ID = IDDescriptografado;
oDependente.DP_DataCadastro = aEmpresa.Emp_DataAtual;
oDependente.DP_Situation = true;
_Control.CadastrarDependente(oDependente);
return(RedirectToAction("Index", new { IDFuncionario = IDFuncionario }));
}
return(View());
}
public Usuario Inserir(string nome, string email, string senha, string telefone)
{
using (var conexao = BancoDeDados.Conexao())
{
conexao.Open();
SqlTransaction transacao = conexao.BeginTransaction();
try
{
string sql = @" Insert into Usuario (Nome, Email, Senha, Telefone, DataCadastro)
Values (@Nome, @Email, @Senha, @Telefone, @DataCadastro) ";
DynamicParameters parametros = new DynamicParameters();
parametros.Add("Nome", nome);
parametros.Add("Email", email);
string senhaCriptografada = Criptografia.GerarHashMD5(senha);
parametros.Add("Senha", senhaCriptografada);
parametros.Add("Telefone", telefone);
parametros.Add("DataCadastro", DateTime.Now);
conexao.Execute(sql, parametros, transacao);
transacao.Commit();
return(this.Listar(null, email, null).FirstOrDefault());
}
catch (Exception e)
{
transacao.Rollback();
throw e;
}
}
}
public ActionResult Cadastro(UsuarioCadastroViewModel model)
{
if (ModelState.IsValid)
{
try
{
Usuario usuario = new Usuario();
usuario.Login = model.Login;
usuario.Nome = model.Nome;
usuario.Senha = Criptografia.EncriptarSenha(model.Senha);
UsuarioRepositorio rep = new UsuarioRepositorio();
if (!rep.HasLogin(usuario.Login))
{
rep.Insert(usuario);
ViewBag.Mensagem = $"Usuário {usuario.Login}, foi cadastrado com sucesso !";
}
else
{
throw new Exception($"Usuário {usuario.Login} já existe no sistema, por favor selecione outro !");
}
ModelState.Clear();
}
catch (Exception ex)
{
ViewBag.Mensagem = "Erro:" + ex.Message;
}
}
return(View());
}
