コード例 #1
0
        private string SaveFile()
        {
            List <Archivo> Lista = DataManagerControlDocumentos.GetArchivo(SelectedDocumento.version.id_version);
            string         nombre_tipo;

            try
            {
                if (SelectedDocumento.id_tipo_documento == 1003 || SelectedDocumento.id_tipo_documento == 1005 || SelectedDocumento.id_tipo_documento == 1006 || SelectedDocumento.id_tipo_documento == 1012 || SelectedDocumento.id_tipo_documento == 1013 || SelectedDocumento.id_tipo_documento == 1014 || SelectedDocumento.id_tipo_documento == 1011)
                {
                    string path = @"\\MXAGSQLSRV01\documents__\POR_APROBAR";

                    switch (SelectedDocumento.id_tipo_documento)
                    {
                    case 1003:
                    case 1013:
                        nombre_tipo = "OHSAS";
                        path        = string.Concat(path, @"\", nombre_tipo, @"\", SelectedDocumento.nombre, SelectedDocumento.version.no_version);
                        break;

                    case 1005:
                    case 1012:
                    case 1011:
                        nombre_tipo = "ESPECIFICOS";
                        path        = string.Concat(path, @"\", nombre_tipo, @"\", SelectedDocumento.nombre, SelectedDocumento.version.no_version);
                        break;

                    case 1006:
                    case 1014:
                        nombre_tipo = "ISO14001";
                        path        = string.Concat(path, @"\", nombre_tipo, @"\", SelectedDocumento.nombre, SelectedDocumento.version.no_version);
                        break;
                    }

                    path = string.Concat(path, SelectedDocumento.version.archivo.ext);

                    File.WriteAllBytes(path, SelectedDocumento.version.archivo.archivo);

                    DataManagerControlDocumentos.UpdateFilePath(SelectedDocumento.version.archivo.id_archivo, path);
                }

                return(null);
            }
            catch (Exception er)
            {
                return(er.ToString());
            }
        }
コード例 #2
0
        /// <summary>
        /// metodo que busca
        /// </summary>
        /// <param name="buscar"></param>
        private void GetUsuario(string usuario)
        {
            Encriptacion encriptar = new Encriptacion();

            ListaUsuarios = DataManagerControlDocumentos.GetUsuarios(usuario);

            if (_ListaUsuarios.Count > 0)
            {
                foreach (var item in ListaUsuarios)
                {
                    //obtiene el id del rol que tiene cada usuario
                    ObservableCollection <Rol> listaRolUsuario = (DataManagerControlDocumentos.GetRol_Usuario(encriptar.encript(item.usuario)));
                    //mandamos llamar una funcion que nos ayudara a obtener el nombre de los roles en base al nombre del usuario
                    item.roles = tipo_rol(listaRolUsuario);
                }
            }
        }
コード例 #3
0
        /// <summary>
        /// Método que muestra la ventana para agregar o quitar centros de trabajo a la leccion aprendida
        /// </summary>
        public void ElegirCentroTrabajo()
        {
            CentrosDeTrabajo Form = new CentrosDeTrabajo();

            ListaCentrosDeTrabajoSeleccionados.Clear();

            Form.DataContext = this;
            Form.ShowDialog();

            //ListaCentrosDeTrabajoSeleccionados.Clear();

            foreach (var item in ListaCentrosDeTrabajo)
            {
                if (item.IsSelected)
                {
                    //Mostramos en la lista los Centros de trabajo que se hayan seleccionado en la vista anterior
                    if (ListaCentrosDeTrabajoSeleccionados.Where(x => x.CentroTrabajo == item.CentroTrabajo).ToList().Count == 0)
                    {
                        ListaCentrosDeTrabajoSeleccionados.Add(item);
                    }
                }
            }

            foreach (var item in ListaCentrosDeTrabajo)
            {
                if (!item.IsSelected)
                {
                    if (ListaCentrosDeTrabajoSeleccionados.Where(x => x.CentroTrabajo == item.CentroTrabajo).ToList().Count > 0)
                    {
                        CentrosTrabajo ct = ListaCentrosDeTrabajoSeleccionados.Where(x => x.CentroTrabajo == item.CentroTrabajo).FirstOrDefault();
                        ListaCentrosDeTrabajoSeleccionados.Remove(ct);
                    }
                }
            }


            ListaCentrosDeTrabajo = DataManagerControlDocumentos.GetCentrosDeTrabajo("");

            foreach (var item in ListaCentrosDeTrabajo)
            {
                if (ListaCentrosDeTrabajoSeleccionados.Where(x => x.CentroTrabajo == item.CentroTrabajo).ToList().Count > 0)
                {
                    item.IsSelected = true;
                }
            }
        }
コード例 #4
0
        /// <summary>
        /// Método que desbloquea el sistema
        /// </summary>
        private async void desbloquear()
        {
            if (id_bloqueo != 0)
            {
                //Declaramos un objeto de tipo MetroDialogSettings al cual le asignamos las propiedades que contendra el mensaje modal.
                MetroDialogSettings setting = new MetroDialogSettings();
                setting.AffirmativeButtonText = StringResources.lblYes;
                setting.NegativeButtonText    = StringResources.lblNo;

                //Ejecutamos el método para mostrar el mensaje. El resultado lo asignamos a una variable local.
                MessageDialogResult result = await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgDesbloquearSistema, setting, MessageDialogStyle.AffirmativeAndNegative);

                if (result == MessageDialogResult.Affirmative)
                {
                    //Declaramos un objeto de tipo Bloqueo
                    Bloqueo obj = new Bloqueo();

                    //Asignamos los valores
                    obj.id_bloqueo = id_bloqueo;

                    //Ejecutamos el método para modificar el estado a desbloqueado
                    int desbloq = DataManagerControlDocumentos.UpdateEstado(obj);

                    //Si se realizó el cambio
                    if (desbloq != 0)
                    {
                        await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgCambiosRealizados);

                        //Obtenemos la pantalla actual, y casteamos para que se tome como tipo MetroWindow.
                        var window = Application.Current.Windows.OfType <MetroWindow>().LastOrDefault();

                        //Verificamos que la pantalla sea diferente de nulo.
                        if (window != null)
                        {
                            //Cerramos la pantalla
                            window.Close();
                        }
                    }
                    else
                    {
                        await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgErrorGeneral);
                    }
                }
            }
        }
コード例 #5
0
        /// <summary>
        /// Método que muetra la pantalla para insertar una nueva lección aprendida
        /// </summary>
        private async void InsertarNuevaLeccion(Usuario ModelUsuario)
        {
            DialogService dialog = new DialogService();

            MetroDialogSettings setting = new MetroDialogSettings();

            setting.AffirmativeButtonText = "+2";
            setting.NegativeButtonText    = "1";

            MessageDialogResult resul = await dialog.SendMessage(StringResources.ttlAlerta, StringResources.lblDescripcionSimilar, setting, MessageDialogStyle.AffirmativeAndNegative);

            if (resul == MessageDialogResult.Affirmative)
            {
                FrmSelect frmLista = new FrmSelect();
                frmLista.DataContext = this;
                bool result = (bool)frmLista.ShowDialog();

                if (result)
                {
                    InsertarComponentes    Descripcion = new InsertarComponentes();
                    InsertarNuevaLeccionVW Context     = new InsertarNuevaLeccionVW(ModelUsuario, true, MotivoSelected);
                    Descripcion.DataContext = Context;
                    Descripcion.ShowDialog();
                }

                Lista = DataManagerControlDocumentos.GetLec("");
            }
            else
            {
                FrmSelect frmLista = new FrmSelect();
                frmLista.DataContext = this;

                bool result = (bool)frmLista.ShowDialog();

                if (result)
                {
                    InsertarNuevaLeccion   Insertar   = new InsertarNuevaLeccion();
                    InsertarNuevaLeccionVW InsertarVW = new InsertarNuevaLeccionVW(ModelUsuario, false, MotivoSelected);
                    Insertar.DataContext = InsertarVW;
                    Insertar.ShowDialog();
                }

                Lista = DataManagerControlDocumentos.GetLec("");
            }
        }
コード例 #6
0
        public NotificarAViewModel(Usuario UsuarioLogeado, string body, ObservableCollection <Archivo> archivos, List <objUsuario> listaANotificar, string title, string origen, int idArchivo)
        {
            Title          = title;
            IsEnableEditor = true;
            User           = UsuarioLogeado;
            ListaArchivos  = archivos;
            Origen         = origen;
            IdArchivo      = idArchivo;


            ListaUsuarios = DataManagerControlDocumentos.GetUsuarios();

            //Si la listaANotificar es decir los usuarios a los que se van a mandar los correos tiene 1 registro
            if (listaANotificar.Count == 1)
            {
                //Se imprime el nombre de la primera posición
                BodyEmail = "<BR>" + definirSaludo() + listaANotificar[0].nombre + ";<BR><BR>" + body + "<br><br>" + definirPieDeCorreo();
            }
            else
            {
                //Sino se imprime "Buenos días a todos / todas" cuando se tiene mas de 1
                BodyEmail = "<BR>" + definirSaludo() + " " + "a todos / a todas;" + "<BR><BR>" + body + "<br><br>" + definirPieDeCorreo();
            }
            ListaGrupos            = DataManagerControlDocumentos.GetAllGrupos(User.NombreUsuario);
            ListaUsuarioANotificar = new ObservableCollection <objUsuario>();

            // Se carga a la lista el usuario reportó
            foreach (var item in listaANotificar)
            {
                ListaUsuarioANotificar.Add(item);
            }

            // Iteramos lista de Usarios a notificar y usuarios para seleccionar
            foreach (var listusernotify in ListaUsuarioANotificar)
            {
                foreach (var listuser in ListaUsuarios)
                {
                    // Seleccionamos en la lista de usuarios, los usuarios a notificar ya cargados
                    if (listusernotify.NombreCorto == listuser.NombreCorto)
                    {
                        listuser.IsSelected = true;
                    }
                }
            }
        }
コード例 #7
0
        /// <summary>
        /// Método para insertar los nuevos centros de trabajo
        /// </summary>
        /// <returns></returns>
        public bool InsertarNuevosCentrosDeTrabajo()
        {
            bool DatosInsertados      = false;
            int  BorrarCentrosTrabajo = DataManagerControlDocumentos.DeleteCentrosDeTrabajoLeccion(id_leccion);

            if (BorrarCentrosTrabajo != 0)
            {
                foreach (var item in ListaCentrosDeTrabajoSeleccionados)
                {
                    int f = DataManagerControlDocumentos.InsertLeccionesCentroDeTrabajo(item.CentroTrabajo, id_leccion);
                    if (f != 0)
                    {
                        DatosInsertados = true;
                    }
                }
            }
            return(DatosInsertados);
        }
コード例 #8
0
        private void NuevaValidacion()
        {
            FrmNuevo_ValidacionDocumento frm     = new FrmNuevo_ValidacionDocumento();
            NuevoValidacionDocumento_VM  context = new NuevoValidacionDocumento_VM();

            frm.DataContext = context;
            frm.ShowDialog();

            if (_SelectedTipoDocumento != null)
            {
                //Inicializamos las listas, para mostrarlas
                InitComp(_SelectedTipoDocumento.id_tipo);
            }
            else
            {
                ListaValidaciones = DataManagerControlDocumentos.GetValidaciones();
            }
        }
コード例 #9
0
 /// <summary>
 /// método que obtiene el documento
 /// segun sea el estatus del documento se ejecuta el metodo correspondiente
 /// </summary>
 /// <param name="txt_buscar"></param>
 private void GetDocument(string txt_buscar)
 {
     if (Estatus.Contains("pendiente"))
     {
         ListaDocumentosValidar = DataManagerControlDocumentos.GetDocumentos_PendientesCorregir(usuario.NombreUsuario, txt_buscar);
     }
     else
     {
         if (Estatus.Contains("todosPendientes"))
         {
             ListaDocumentosValidar = DataManagerControlDocumentos.GetDocumentos_PendientesCorregir(txt_buscar);
         }
         else
         {
             ListaDocumentosValidar = DataManagerControlDocumentos.GetDocumentos_PendientesLiberar(txt_buscar);
         }
     }
 }
コード例 #10
0
        private void verArchivo(int idVersion)
        {
            ObservableCollection <Archivo> archivos = DataManagerControlDocumentos.GetArchivos(idVersion, false);

            if (archivos.Count > 0)
            {
                Archivo archivo = archivos[0];
                try
                {
                    string filename = GetPathTempFile(archivo);
                    File.WriteAllBytes(filename, archivo.archivo);
                    Process.Start(filename);
                }
                catch (Exception)
                {
                }
            }
        }
コード例 #11
0
        /// <summary>
        /// Método para insertar los nuevos tipos de cambio
        /// </summary>
        /// <returns></returns>
        public bool InsertarNuevosTiposDeCambio()
        {
            bool DatosInsertados = false;

            int BorrarTiposCambio = DataManagerControlDocumentos.DeleteTiposDeCambioLeccion(id_leccion);

            if (BorrarTiposCambio != 0)
            {
                foreach (var item in ListaTipoCambioLeccion)
                {
                    int a = DataManagerControlDocumentos.InsertLeccionesNivelCambio(item.ID_TIPOCAMBIO, id_leccion);
                    if (a != 0)
                    {
                        DatosInsertados = true;
                    }
                }
            }
            return(DatosInsertados);
        }
コード例 #12
0
        /// <summary>
        /// Método que muestra la ventana con la información del documento seleccionado
        /// Se muestra ventana para validar el documento
        /// </summary>
        private void abrirDocumento()
        {
            //Si se ha seleccionado un documento
            if (selectedDocumento != null)
            {
                //Obtiene la información de un documento y la versión
                SelectedDocumento = DataManagerControlDocumentos.GetDocumento(SelectedDocumento.id_documento, SelectedDocumento.version.no_version);

                FrmValidarDocumento p = new FrmValidarDocumento();

                ValidarDocumentoViewM context = new ValidarDocumentoViewM(SelectedDocumento, usuario);

                p.DataContext = context;

                p.ShowDialog();

                init();
            }
        }
コード例 #13
0
ファイル: Program.cs プロジェクト: raulbanuelos/DesingProcess
        static void initConvertedWord()
        {
            Console.WriteLine("Iniciando con los documentos de Word");
            List <FO_Item> listTipoDocumento = new List <FO_Item>();

            //listTipoDocumento.Add(new FO_Item { id = 1003, Nombre = "OHSAS" });
            //listTipoDocumento.Add(new FO_Item { id = 1013, Nombre = "OHSAS" });
            //listTipoDocumento.Add(new FO_Item { id = 1005, Nombre = "ESPECIFICOS" });
            //listTipoDocumento.Add(new FO_Item { id = 1011, Nombre = "ESPECIFICOS" });
            //listTipoDocumento.Add(new FO_Item { id = 1012, Nombre = "ESPECIFICOS" });
            listTipoDocumento.Add(new FO_Item {
                id = 1006, Nombre = "ISO14001"
            });
            //listTipoDocumento.Add(new FO_Item { id = 1014, Nombre = "ISO14001" });

            foreach (var tipoDocumento in listTipoDocumento)
            {
                ObservableCollection <Documento> documentos = DataManagerControlDocumentos.GetDocumentoByTipoDocumento(tipoDocumento.id, string.Empty);

                foreach (var documento in documentos)
                {
                    ObservableCollection <Archivo> archivos = DataManagerControlDocumentos.GetArchivos(documento.version.id_version, true);
                    foreach (var archivo in archivos)
                    {
                        string pathFile = @"\\mxagsqlsrv01\documents__\" + tipoDocumento.Nombre + @"\" + documento.nombre + documento.version.no_version + archivo.ext;
                        int    r        = DataManagerControlDocumentos.UpdateFilePath(archivo.id_archivo, pathFile);

                        if (r <= 0)
                        {
                            Console.WriteLine("Error al guardar el path en BD, ID_ARCHIVO: " + archivo.id_archivo + "  DOCUMENTO: " + documento.nombre);
                        }
                        else
                        {
                            Console.WriteLine("Cambio realizado en documento: " + documento.nombre);
                        }
                    }
                    archivos = new ObservableCollection <Archivo>();
                }
            }

            Console.WriteLine("Proceso terminado de archivos de word");
        }
コード例 #14
0
        /// <summary>
        /// Método para eliminar un archivo de  las lecciones aprendidas.
        /// </summary>
        /// <param name="item"></param>
        ///
        private async void eliminarItem(Archivo_LeccionesAprendidas item)
        {
            //Incializamos los servicios de dialog.
            DialogService dialogService = new DialogService();

            if (item != null)
            {
                //Declaramos un objeto de tipo MetroDialogSettings al cual le asignamos las propiedades que contendra el mensaje modal.
                MetroDialogSettings setting = new MetroDialogSettings();
                setting.AffirmativeButtonText = StringResources.lblYes;
                setting.NegativeButtonText    = StringResources.lblNo;

                //Ejecutamos el método para mostrar el mensaje. El resultado lo asignamos a una variable local.
                MessageDialogResult result = await dialogService.SendMessage(StringResources.ttlAlerta, StringResources.msgDelArchivo, setting, MessageDialogStyle.AffirmativeAndNegative);

                if (item != null & result == MessageDialogResult.Affirmative)
                {
                    //Se elimina el item seleccionado de la listaDocumentos.
                    ListaDocumentos.Remove(item);

                    //Comparamos si el archivo se debe eliminar de la base de datos.
                    if (item.ID_ARCHIVO_LECCIONES != 0 && item.ID_LECCIONES_APRENDIDAS != 0)
                    {
                        //Se elimina de la base de datos.
                        int n = DataManagerControlDocumentos.Delete_Archivo_Lecciones(item.ID_ARCHIVO_LECCIONES);

                        if (n > 0)
                        {
                            await dialogService.SendMessage(StringResources.ttlAlerta, StringResources.msgArchivoEliminadoCorrectamente);
                        }
                        else
                        {
                            await dialogService.SendMessage(StringResources.msgError, StringResources.msgArchivoEliminadoFallido);
                        }
                    }
                    else
                    {
                        await dialogService.SendMessage(StringResources.ttlAlerta, StringResources.msgArchivoEliminadoCorrectamente);
                    }
                }
            }
        }
コード例 #15
0
        // Constructor para visualizar grupos y ver usuarios integrantes
        public GruposViewModel(int idGrupoSeleccionado, Usuario usuariolog)
        {
            user = usuariolog;
            IdGrupoSeleccionado    = idGrupoSeleccionado;
            ListaIntegrantes_Grupo = DataManagerControlDocumentos.GetAllIntegrantesGrupo(idGrupoSeleccionado);
            ListaIntegrantes_Grupo = ListaIntegrantes_Grupo;
            NotifyChange("ListaIntegrantes_Grupo");
            ListadeUsuarios = DataManagerControlDocumentos.GetUsuarios();

            foreach (var usuariointegrante in ListaIntegrantes_Grupo)
            {
                foreach (var usuario in ListadeUsuarios)
                {
                    if (usuariointegrante.idusuariointegrante == usuario.usuario)
                    {
                        usuario.IsSelected = true;
                    }
                }
            }
        }
コード例 #16
0
        private bool rechazar(Documento objDocumento)
        {
            Console.WriteLine("Deja empiezo a rechazar el documento...");
            System.Threading.Thread.Sleep(3000);

            int last_id = DataManagerControlDocumentos.GetID_LastVersion(objDocumento.id_documento, objDocumento.version.id_version);

            if (last_id == 0)
            {
                objDocumento.id_estatus = 3;
                int n = DataManagerControlDocumentos.Update_EstatusDocumento(objDocumento);

                if (n != 0)
                {
                    objDocumento.version.id_estatus_version = 4;
                    //Se llama al método para actualizar el estatus de la version
                    int update_version = DataManagerControlDocumentos.Update_EstatusVersion(objDocumento.version, User, objDocumento.nombre);
                    Console.WriteLine("Listo documento rechazado");
                    System.Threading.Thread.Sleep(3000);

                    return(true);
                }
                else
                {
                    Console.WriteLine("Hubo un error al querer rechazar el documento: " + objDocumento.nombre);
                    return(false);
                }
            }
            else
            {
                objDocumento.version.id_estatus_version = 4;
                //Se llama al método para actualizar el estatus de la version
                int update_version = DataManagerControlDocumentos.Update_EstatusVersion(objDocumento.version, User, objDocumento.nombre);
                Console.WriteLine("Listo documento rechazado");
                System.Threading.Thread.Sleep(3000);
                return(true);
            }
        }
コード例 #17
0
        /// <summary>
        /// Método que agrega una marca de agua a los documentos que no son formatos ni ayudas visuales.
        /// </summary>
        /// <param name="version"></param>
        private bool SetElectronicStamp(Model.ControlDocumentos.Version version)
        {
            bool res = false;

            BaseFont bfTimes = BaseFont.CreateFont(BaseFont.TIMES_ROMAN, BaseFont.CP1252, false);
            ObservableCollection <Archivo> archivos = DataManagerControlDocumentos.GetArchivos(version.id_version, true);

            DateTime fecha_sello = DataManagerControlDocumentos.Get_DateTime();

            string dia  = fecha_sello.Day.ToString().Length == 1 ? "0" + fecha_sello.Day : fecha_sello.Day.ToString();
            string anio = fecha_sello.Year.ToString();
            string mes  = fecha_sello.Month.ToString().Length == 1 ? "0" + fecha_sello.Month : fecha_sello.Month.ToString();

            string fecha = dia + "/" + mes + "/" + anio;

            Documento documento       = DataManagerControlDocumentos.GetDocumento(version.id_version);
            int       contadorArchivo = 0;

            foreach (Archivo item in archivos)
            {
                string waterMarkText  = "MAHLE CONTROL DE DOCUMENTOS / DOCUMENTO LIBERADO ELECTRÓNICAMENTE Y TIENE VELIDEZ SIN FIRMA." + " DISPOSICIÓN: " + fecha;
                string waterMarkText2 = "ÚNICAMENTE TIENE VALIDEZ EL DOCUMENTO DISPONIBLE EN INTRANET.";
                string waterMarkText3 = "LAS COPIAS NO ESTÁN SUJETAS A NINGÚN SERVICIO DE ACTUALIZACIÓN";

                byte[] newarchivo = AddWatermark(item.archivo, bfTimes, waterMarkText, waterMarkText2, waterMarkText3);

                item.archivo = newarchivo;

                item.ruta = saveFileToServer(item, documento.id_tipo_documento, documento.nombre, version.no_version, contadorArchivo);

                int r = DataManagerControlDocumentos.UpdateArchivo(item);

                res = r == 0 ? false : true;
                contadorArchivo++;
            }

            return(res);
        }
コード例 #18
0
        /// <summary>
        /// Método para eliminar una leccion
        /// </summary>
        private async void eliminarLeccion()
        {
            //declaramos un objeto del tipo dialos service
            DialogService diaog = new DialogService();
            //declaramos los botones
            MetroDialogSettings button = new MetroDialogSettings();

            //asigamos los valores a los botones
            button.AffirmativeButtonText = StringResources.lblYes;
            button.NegativeButtonText    = StringResources.lblNo;

            //preguntamos si se desea eliminar la leccion aprendida
            MessageDialogResult result = await diaog.SendMessage(StringResources.ttlAlerta, StringResources.msgEliminarLeccion, button, MessageDialogStyle.AffirmativeAndNegative);

            if (result == MessageDialogResult.Affirmative)
            {
                //borramos la leccion de la base de datos
                int delete = DataManagerControlDocumentos.Delete_Lecciones(id_leccion);
                //verificamos que se haya eliminado la leccion
                if (delete > 0)
                {
                    await diaog.SendMessage(StringResources.ttlAlerta, StringResources.msgEliminacionCorrectaLeccion);

                    //obtenemos la ventana actual
                    var window = Application.Current.Windows.OfType <MetroWindow>().LastOrDefault();

                    if (window != null)
                    {
                        //cerramos la ventana
                        window.Close();
                    }
                }
                else
                {
                    await diaog.SendMessage(StringResources.msgError, StringResources.msgErrorGeneral);
                }
            }
        }
コード例 #19
0
        private bool iniciarRechazo(int idSolicitud, int idVersion, string comentario)
        {
            Documento objDocumento = DataManagerControlDocumentos.GetDocumento(idVersion);

            objDocumento.version = DataManagerControlDocumentos.GetVersion(idVersion);

            if (rechazar(objDocumento))
            {
                if (notificarRechazo(objDocumento, comentario))
                {
                    //Establecemos que esta solicitud ya fué realizada.
                    DataManagerControlDocumentos.setDoneSolicitudControlDocumentos(idSolicitud);

                    //Eliminamos el registro de la tabla solictudes.
                    DataManagerControlDocumentos.deleteSolicitudControlDocumentos(idSolicitud);

                    Console.WriteLine("Listo Campeón!!, este documento ya está en estatus de pendientes por corregir");
                    System.Threading.Thread.Sleep(2000);
                    Console.WriteLine("Deja voy por unas papas y una coca, cualquier cosa estoy al pendiente.");
                }
            }
            return(true);
        }
コード例 #20
0
        /// <summary>
        /// Método que inicializa la lista de validacion y lista de relación
        /// Muestra las validaciones que no contiene un tipo de documento
        /// </summary>
        /// <param name="idTipo"></param>
        private void InitComp(int idTipo)
        {
            //Obtenemos las relaciones de acuerdo al tipo de documento
            ListaR = DataManagerControlDocumentos.GetValidacion_Documento(idTipo);
            //Volvemos a inicializar las lista de validaciones
            ListaValidaciones = DataManagerControlDocumentos.GetValidaciones();

            //Iteramos la lista de Relaciones
            foreach (var item in ListaR)
            {
                //Iteramos la lista de validaciones
                foreach (var var in ListaValidaciones)
                {
                    //Si el objeto de la ListaR se encuentra en la lista de Validaciones
                    if (var.id_validacion == item.id_validacion)
                    {
                        //Borramos el objto de la lista
                        ListaValidaciones.Remove(var);
                        break;
                    }
                }
            }
        }
コード例 #21
0
        /// <summary>
        /// Método para actualizar lista de integrantes por grupo.
        /// </summary>
        /// <returns></returns>
        public void guardarnintegrantes()
        {
            //Eliminar integrantes de la lista
            foreach (var usuariointegrante in ListaIntegrantes_Grupo)
            {
                DataManagerControlDocumentos.eliminarintegrantes(IdGrupoSeleccionado, usuariointegrante.idusuariointegrante);
            }

            // Agregar integrantes a la lista
            foreach (var usuario in ListadeUsuarios)
            {
                if (usuario.IsSelected)
                {
                    DataManagerControlDocumentos.agregarintegrante(IdGrupoSeleccionado, usuario.usuario);
                }
            }

            // Se llena la lista de integrantes por grupo
            ListaIntegrantes_Grupo = DataManagerControlDocumentos.GetAllIntegrantesGrupo(IdGrupoSeleccionado);
            ListaIntegrantes_Grupo = ListaIntegrantes_Grupo;
            NotifyChange("ListaIntegrantes_Grupo");
            iragregarintegrante();
        }
コード例 #22
0
        public ModificarDatosUsuario(objUsuario SelectedItem)
        {
            //Asiganmos los valores para que se muestren
            if (SelectedItem != null)
            {
                usuario    = SelectedItem.usuario;
                nombre     = SelectedItem.nombre;
                Contraseña = SelectedItem.password;
                Apaterno   = SelectedItem.APaterno;
                Amaterno   = SelectedItem.AMaterno;
                correo     = SelectedItem.Correo;

                if (string.IsNullOrEmpty(SelectedItem.Pathnsf))
                {
                    patnsf = "";
                }
                else
                {
                    patnsf = SelectedItem.Pathnsf;
                }

                ListaTotdosRoles = DataManagerControlDocumentos.GetRol();

                Encriptacion encriptar = new Encriptacion();
                string       user      = encriptar.encript(SelectedItem.usuario);
                ListaRol = DataManagerControlDocumentos.GetRol_Usuario(user);

                //muestra los roles que el usuario tenga
                foreach (var item in ListaTotdosRoles)
                {
                    if (existe(item.id_rol, ListaRol))
                    {
                        item.selected = true;
                    }
                }
            }
        }
コード例 #23
0
        /// <summary>
        /// Contructor para sellar copias documentos
        /// </summary>
        /// <param name="usuario"></param>
        /// <param name="usuarioautorizo"></param>
        public UsuariosViewModel(string usuario, string usuarioautorizo)
        {
            ListaUsuariosCorreo = DataManagerControlDocumentos.GetUsuarios();

            // iteramos la lista para seleccionar a los usuarios a notificar al momento de abrir la ventana.
            foreach (var item in ListaUsuariosCorreo)
            {
                //sleccionamos el administrado del sistema para notificar
                if (item.usuario == "¢¥®ª¯")
                {
                    item.IsSelected = true;
                }
                //seleccionamos al usuario que elaboro
                if (item.usuario == usuario)
                {
                    item.IsSelected = true;
                }
                //seleccionamos al usuario que autorizo
                if (item.usuario == usuarioautorizo)
                {
                    item.IsSelected = true;
                }
            }
        }
コード例 #24
0
        public EstatusDocumentosVM(Usuario _usuario)
        {
            usuario = _usuario;
            ListaDocumentosConEstatus    = DataManagerControlDocumentos.GetDocumentosEstatus(usuario.NombreUsuario, "");
            ListaDocumentosSeleccionados = new ObservableCollection <Documento>();

            foreach (Documento item in ListaDocumentosConEstatus)
            {
                switch (item.version.id_estatus_version)
                {
                case 4:
                    item.ruta = @"\Images\TLROJO.png";
                    break;

                case 3:
                    item.ruta = @"\Images\TLAMARILLO.png";
                    break;

                case 5:
                    item.ruta = @"\Images\TLVERDE.png";
                    break;
                }
            }
        }
コード例 #25
0
        /// <summary>
        /// Constructor para cargar usuarios suscritos al eliminar documento
        /// </summary>
        /// <param name="ListaUsuariosSuscritosParaEliminar"></param>
        /// <param name="usuario"></param>
        /// <param name="usuarioautorizo"></param>
        public UsuariosViewModel(ObservableCollection <DO_UsuarioSuscrito> ListaUsuariosSuscritosParaEliminar, string usuario, string usuarioautorizo)
        {
            ListaUsuariosCorreo = DataManagerControlDocumentos.GetUsuarios();

            // iteramos la lista para seleccionar a los usuarios a notificar al momento de abrir la ventana.
            foreach (var item in ListaUsuariosCorreo)
            {
                //sleccionamos el administrado del sistema para notificar
                if (item.usuario == "¢¥®ª¯")
                {
                    item.IsSelected = true;
                }
                //seleccionamos al usuario que elaboro
                if (item.usuario == usuario)
                {
                    item.IsSelected = true;
                }
                //seleccionamos al usuario que autorizo
                if (item.usuario == usuarioautorizo)
                {
                    item.IsSelected = true;
                }
            }

            // Iteramos la lista con usuarios suscritos y los cargamos a la lista general para notificar
            foreach (var UserSuscritos in ListaUsuariosSuscritosParaEliminar)
            {
                foreach (var User in ListaUsuariosCorreo)
                {
                    if (UserSuscritos.id_usuariosuscrito == User.usuario)
                    {
                        User.IsSelected = true;
                    }
                }
            }
        }
コード例 #26
0
        /// <summary>
        /// Método que busca los centros de trabajo
        /// </summary>
        /// <param name="TextoBuscar"></param>
        public void EncontrarCentroTrabajo(string TextoBuscar)
        {
            foreach (var item in ListaCentrosDeTrabajo)
            {
                if (item.IsSelected)
                {
                    //Mostramos en la lista los niveles de cambio que se hayan seleccionado en la vista anterior
                    if (ListaCentrosDeTrabajoSeleccionados.Where(x => x.CentroTrabajo == item.CentroTrabajo).ToList().Count == 0)
                    {
                        ListaCentrosDeTrabajoSeleccionados.Add(item);
                    }
                }
            }

            //ListaCentrosDeTrabajo.Clear();
            ObservableCollection <CentrosTrabajo> Aux = new ObservableCollection <CentrosTrabajo>();

            //ListaCentrosDeTrabajo = DataManagerControlDocumentos.GetCentrosDeTrabajo(TextoBuscar);

            Aux = DataManagerControlDocumentos.GetCentrosDeTrabajo(TextoBuscar);

            ListaCentrosDeTrabajo.Clear();

            foreach (var item in Aux)
            {
                ListaCentrosDeTrabajo.Add(item);
            }

            foreach (var item in ListaCentrosDeTrabajo)
            {
                if (ListaCentrosDeTrabajoSeleccionados.Where(x => x.CentroTrabajo == item.CentroTrabajo).ToList().Count > 0)
                {
                    item.IsSelected = true;
                }
            }
        }
コード例 #27
0
        private async Task <bool> sellar(int idVersion)
        {
            bool respuesta = false;

            Console.WriteLine("Estoy sellando el documento....");

            Model.ControlDocumentos.Version version = DataManagerControlDocumentos.GetVersion(idVersion);
            int idTipoDocumento = DataManagerControlDocumentos.GetTipoDocumentoByIdVersion(idVersion);

            respuesta = await SetElectronicStamp(version, idTipoDocumento);

            System.Threading.Thread.Sleep(3000);

            Console.WriteLine("Mientras lo voy sellando, recuerdo cuando sellabas el documento a mano... que fácil te estoy haciendo la vida.....");
            System.Threading.Thread.Sleep(6000);

            Console.WriteLine("Listo, documento sellado...");
            System.Threading.Thread.Sleep(4000);

            Console.WriteLine("Ahora vamos a lo que sigue.");
            System.Threading.Thread.Sleep(3000);

            return(respuesta);
        }
コード例 #28
0
 public DocumentosVencidosVM(string usuario)
 {
     ListaDocumentos = DataManagerControlDocumentos.GetDocumentos_Vencidos(usuario);
 }
コード例 #29
0
 /// <summary>
 /// Método que obtiene los Centros de trabajo y los nombres de operación
 /// </summary>
 private void agregarCentroTrabajo()
 {
     _ListaCentroTrabajo = DataManagerControlDocumentos.GetCentroTrabajo("");
 }
コード例 #30
0
        /// <summary>
        /// Método para guardar la nueva información
        /// </summary>
        public async void guardardatosnvacontrasenia()
        {
            //Incializamos los servicios de dialog.
            DialogService dialog = new DialogService();

            //Declaramos un objeto con el cual se realiza la encriptación
            Encriptacion encriptar = new Encriptacion();

            if (!string.IsNullOrEmpty(Contraseña) && !string.IsNullOrEmpty(ConfirmarContraseña))
            {
                // Validamos la longuitud de la contraseña
                if (Contraseña.Length >= 7 && ConfirmarContraseña.Length >= 7)
                {
                    // Validamos que sean iguales
                    if (Contraseña == ConfirmarContraseña)
                    {
                        // Validamos que la contraseña nueva sea diferente a la anterior
                        if (ConfirmarContraseña != encriptar.desencript(User.Password))
                        {
                            // Actualizamos el registro de la contraseña en la tabla Usuarios
                            DataManagerControlDocumentos.UpdatePass(User.NombreUsuario, encriptar.encript(Contraseña));

                            // Declaramos el valor a 0
                            bool temporal_password = false;

                            // Actualizar el valor de temporal password
                            DataManager.Update_TemporalPassword(User.NombreUsuario, temporal_password);

                            //Obtenemos la pantalla actual, y casteamos para que se tome como tipo MetroWindow.
                            var window = System.Windows.Application.Current.Windows.OfType <MetroWindow>().LastOrDefault();

                            // Cambiamos la variable a verdadero
                            CierrePantalla = true;

                            //Mensaje de que la contrase;a se guardo correctamente
                            await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgContraseñaGuardada);

                            //Verificamos que la pantalla sea diferente de nulo
                            if (window != null)
                            {
                                //Cerramos la pantalla
                                window.Close();
                            }
                        }
                        else
                        {
                            //Mensaje para notificar que  la contraseña no debe de ser igual a la anterior.
                            await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgContraseñaNoValida);
                        }
                    }
                    else
                    {
                        // Mensaje para notificar que las constraseñas no coinciden.
                        await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgContraseñaActualDiferente);
                    }
                }
                else
                {
                    // Mensaje para notificar que las constraseñas necesita más carácteres.
                    await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgErrorContraseña);

                    //msgErrorContraseña
                }
            }
            else
            {
                // Mensaje para notificar que las constraseñas necesita más carácteres
                await dialog.SendMessage(StringResources.ttlAlerta, StringResources.msgErrorContraseña);

                //msgErrorContraseña
            }
        }