public TOTransaction SetNewPassword(string usu_codi, string usu_idpk)
        {
            try
            {
                var insta = DAO_Gn_Insta.GetGnInsta();
                if (insta.par_ccln == "S")
                {
                    if (!containsLetters(usu_idpk))
                    {
                        throw new Exception("Su clave debe contener letras y números");
                    }
                    if (!usu_idpk.Any(char.IsDigit))
                    {
                        throw new Exception("Su clave debe contener letras y números");
                    }
                }
                if (usu_idpk.Length < insta.par_nmin)
                {
                    throw new Exception(string.Format("Su clave debe contener al menos {0} caracteres", insta.par_nmin));
                }
                if (usu_idpk.Length > insta.par_nmax)
                {
                    throw new Exception(string.Format("Su clave debe contener máximo {0} caracteres", insta.par_nmax));
                }

                usu_idpk = Encrypta.EncriptarClave(usu_idpk);
                int update = new DAO_Gn_Usuar().updatePassword(usu_codi, usu_idpk);
                if (update == 0)
                {
                    throw new Exception("No se actualizó ningún registro");
                }
                return(new TOTransaction()
                {
                    Retorno = 0, TxtError = ""
                });
            }
            catch (Exception ex)
            {
                return(new TOTransaction()
                {
                    Retorno = 1, TxtError = ex.Message
                });
            }
        }
        public void SendMailForgetPasswordToUser(string usu_codi, string token, string link)
        {
            Gn_Insta insta = DAO_Gn_Insta.GetGnInsta();

            if (insta == null)
            {
                throw new Exception("Parámetros de instalación no definidos");
            }

            var transact = GetGnUsuar(usu_codi);

            if (transact.Retorno == 0)
            {
                if (!IsValidMail(transact.ObjTransaction.usu_corr))
                {
                    throw new Exception("No ha sido posible enviar el código de verificación porque el email asociado al usuario no es válido");
                }

                //Crear cuerpo del correo

                StringBuilder mail = new StringBuilder();
                mail.Append(string.Format("<b>Señor Usuario {0}</b> <br>", transact.ObjTransaction.usu_codi));
                mail.Append(string.Format("Usted ha iniciado un proceso de cambio de contraseña, el cual podrá continuar en el siguiente  <a href='{0}?token={1}' target='_blank'>link</a> ", link, token));
                mail.Append(string.Format("<br><b>Si el hipervínculo no funciona correctamente, copie y pegue la siguiente Url en su navegador:</b> <br> {0}?token={1}", link, token));
                mail.Append("<br> Si no ha iniciado este proceso por favor ignore este mail");


                //Enviar mail
                List <string> mails = new List <string>()
                {
                    transact.ObjTransaction.usu_corr
                };
                var envio = MailHelper.SendMail(mails.ToArray(), "CAMBIO DE CONTRASEÑA SELFSERVICE", mail.ToString(), insta.par_mail, insta.par_host, insta.par_mail, insta.par_clma, int.Parse(insta.par_pcor), insta.par_ussl == "S", true);

                //Retornar mail al cual  se envió el token
            }
            else
            {
                throw new Exception(string.Format("El usuario {0} no existe", usu_codi));
            }
        }
Ejemplo n.º 3
0
        public Boolean newGnAdjun(int emp_codi, string pro_codi, int cont, string rad_tabl, byte[] file, string name, string usu_codi, string type = "S")
        {
            try
            {
                var insta = DAO_Gn_Insta.GetGnInsta();


                Stream stream   = new MemoryStream(file);
                string fileName = "";
                switch (type)
                {
                case "S":

                    /*consultar si ya existe algún registro para sacar el consecutivo, sino se busca consecutivo*/
                    int      rad_cont = 0;
                    Gn_Radju rad      = new DAO_Gn_Radju().GetGnRadju(emp_codi, string.Concat(emp_codi, cont), pro_codi);
                    if (rad != null)
                    {
                        rad_cont = rad.rad_cont;
                    }
                    else
                    {
                        var consec = new DAO_Gn_Conse().getGnConse(emp_codi);
                        if (consec == 0)
                        {
                            throw new Exception(string.Format(
                                                    "No se encontró consecutivo para la empresa {0} y código consecutivo {1}",
                                                    emp_codi, "325"));
                        }
                        rad_cont = consec + 1;
                    }


                    int?r = null;

                    if (rad == null)
                    {
                        //Primero guardamos en la tabla de adjuntos
                        r = new DAO_Gn_Radju().InsertarGnRadju(new Gn_Radju()
                        {
                            rad_cont = rad_cont,
                            rad_tabl = rad_tabl,
                            pro_codi = pro_codi,
                            rad_llav = string.Concat(emp_codi, cont),
                            emp_codi = emp_codi
                        }, usu_codi);
                        if (r == null)
                        {
                            throw new Exception("Ha ocurrido un error al guardar el archivo adjunto");
                        }

                        //Actualiza el gn conse
                        //new DAO_Gn_Conse().updateGnConse(rad_cont, 325, double.Parse(string.Concat(emp_codi, cont)));
                    }



                    List <Gn_Adjun> adjunts  = new DAO_Gn_Adjun().GetAdjun(emp_codi, rad_cont);
                    int             adj_cont = adjunts == null || !adjunts.Any() ? 1 : adjunts.Max(o => o.adj_cont) + 1;
                    Gn_Adjun        adjun    = new Gn_Adjun();
                    adjun.rad_cont = rad_cont;
                    adjun.adj_cont = adj_cont;
                    adjun.adj_nomb = name;
                    adjun.adj_tipo = "A";
                    adjun.aud_usua = usu_codi;
                    adjun.emp_codi = emp_codi;
                    r = new DAO_Gn_Adjun().insertGnAdju(adjun);
                    if (r == null)
                    {
                        throw new Exception("Ha ocurrido un error al guardar el archivo adjunto");
                    }
                    fileName = string.Format("{0}_{1}_{2}_{3}", rad_tabl,
                                             emp_codi, rad_cont, adj_cont);
                    //System.IO.FileStream fs = new System.IO.FileStream(pathFile, System.IO.FileMode.Open, System.IO.FileAccess.Read);
                    //System.IO.MemoryStream ms = new System.IO.MemoryStream();
                    //fs.CopyTo(ms);

                    if (insta.par_adju == "F")
                    {
                        Digitalware.Apps.Utilities.TO.ActionResult result = FTPManager
                                                                            .FileUpload(stream, rad_tabl + "/" + fileName);
                        if (!result.State)
                        {
                            throw new Exception(result.Message);
                        }
                    }
                    if (insta.par_adju == "B")
                    {
                        //Consultamos si hay adjuntos para obtener el adj_cont
                        List <Gn_AdJfi> adjfi = new DAO_Gn_AdJfi().GetAdjFi(emp_codi, rad_cont);
                        adj_cont = adjfi == null || !adjfi.Any() ? 1 : adjfi.Max(j => j.adj_cont + 1);

                        //byte[] fileAdj = FTPManager.DownloadFtp(pathFile, Path.GetFileNameWithoutExtension(pathFile));
                        //  string hex = Helpers.ByteArrayToString(files[i].data);
                        new DAO_Gn_AdJfi().insertGnAdjfi(new Gn_AdJfi {
                            adj_cont = adj_cont, adj_file = file, rad_cont = rad_cont, emp_codi = emp_codi
                        }, usu_codi);
                    }

                    return(true);

                case "W":

                    int             doc_cont    = 1;
                    List <Wf_Cdocu> filesExists = new DAO_Wf_Cdocu().GetWfCdocu(emp_codi, cont);
                    if (filesExists != null && filesExists.Any())
                    {
                        doc_cont = filesExists.Max(o => o.doc_cont) + 1;
                    }

                    fileName = string.Format("{0}_{1}_{2}_{3}", emp_codi,
                                             cont, doc_cont, name);
                    if (insta.par_adju == "F" || insta.par_adju == "B")
                    {
                        var newWfCdocu = new DAO_Wf_Cdocu().insertWfCdocu(new Wf_Cdocu()
                        {
                            cas_cont = cont,
                            doc_cont = doc_cont,
                            doc_desc = name,
                            emp_codi = emp_codi,
                            aud_usua = usu_codi,
                            doc_blob = file
                        });

                        Digitalware.Apps.Utilities.TO.ActionResult result = FTPManager
                                                                            .FileUpload(stream, fileName, string.Format("WORKFLOW/{0}/{1}/WF_CDOCU/", emp_codi, DateTime.Now.Year));
                        if (!result.State)
                        {
                            throw new Exception(result.Message);
                        }
                    }

                    return(true);

                default:
                    return(false);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(string.Format("Error insertando adjunto:{0}", ex.Message));
            }
        }