public Response DelApplicationAdministration(ApplicationPMX application, User user)
        {
            var response = new Response {
                Message = "Sin inicializar.", Result = false
            };
            var applicationDa = new ApplicationDA(_configuration);

            try
            {
                if (application == null)
                {
                    response.Message = "El objeto application no puede ser nulo";
                    return(response);
                }
                if (user == null)
                {
                    response.Message = "El objeto user no puede ser nulo";
                    return(response);
                }

                var log = new Log
                {
                    Application = new ApplicationPMX {
                        ApplicationName = _applicationName
                    },
                    EventUser      = user,
                    EventTypeId    = LogTypeEnum.Notification,
                    LogDescription = string.Format("Removió la cuenta {0} de la configuración que permite ejercer sus permisos de SeguridadApp en la aplicación {1}.", user.UserId, application.ApplicationName)
                };
                var loglogic = new LogLogic(_configuration);
                loglogic.InsertLogEvent(log);
                loglogic.Dispose();


                applicationDa.DelApplicationAdministration(application, user);
                response.Message =
                    string.Format(
                        "Se ha eliminado la cuenta del usuario {0} que permite ejercer sus permisos de SeguridadApp en la aplicación {1}.",
                        user.UserId, application.ApplicationName);
                response.Result = true;
            }
            catch (Exception err)
            {
                var log = new Log
                {
                    EventUser      = user,
                    EventTypeId    = LogTypeEnum.Notification,
                    LogDescription = string.Format("Se intentó eliminar la cuenta del usuario {0} para la aplicacion {1} , pero ocurrio un error. {2}", user.UserId, application.ApplicationName, err.Message),
                    Application    = new ApplicationPMX
                    {
                        ApplicationName =
                            _applicationName
                    }
                };
                var loglogic    = new LogLogic(_configuration);
                var responseLog = loglogic.InsertLogEvent(log);
                loglogic.Dispose();

                response.Message = string.Format("Ocurrio un error al intentar eliminar la cuenta del usuario {0} para la aplicacion. {1} {2}", user.UserId, responseLog.Message, DateTime.Now.ToString(CultureInfo.InvariantCulture));
                response.Result  = false;
            }
            applicationDa.Dispose();
            return(response);
        }
示例#2
0
        public Response DelUser(User user, User registerUser)
        {
            var response = new Response {
                Message = "Sin inicializar", Result = false
            };

            try
            {
                #region AddUserDataValidation
                if (string.IsNullOrEmpty(user.UserId))
                {
                    response.Message = "El usuario no puede estar vacío";
                    return(response);
                }

                if (string.IsNullOrEmpty(user.EmployeeNumber))
                {
                    response.Message = "El campo ficha no puede estar vacío";
                    return(response);
                }

                //if (Convert.ToDateTime(user.DeclineDate).Year != DateTime.Now.Year)
                //{
                //    response.Message = "El año de inicio de vigencia no puede ser distinto al actual. ";
                //    return response;
                //}

                if (registerUser == null)
                {
                    response.Message = "No se ha especificado el usuario con permisos para registrar";
                    return(response);
                }
                #endregion
                var userDa = new UserDA(_configuration);
                userDa.DelUser(user, registerUser);
                userDa.Dispose();
                #region logRegister

                var log = new Log
                {
                    Application = new ApplicationPMX
                    {
                        ApplicationName =
                            _applicationName
                    },
                    EventUser      = registerUser,
                    EventTypeId    = LogTypeEnum.Notification,
                    LogDescription = string.Format("Declinó la cuenta {0} asignado a F-{1} - {2}, Vigente hasta {3} ",
                                                   user.UserId, user.EmployeeNumber, user.EmployeeNames + " " + user.EmployeeLastName, user.DeclineDate)
                };
                #endregion
                var loglogic = new LogLogic(_configuration);
                loglogic.InsertLogEvent(log);
                loglogic.Dispose();



                response.Message = "Se declino correctamente el usuario para uso de aplicaciones.";
                response.Result  = true;
            }
            catch (Exception err)
            {
                if (err.Message.Substring(0, 35) == "Violation of PRIMARY KEY constraint")
                {
                    var log = new Log
                    {
                        EventUser      = registerUser,
                        EventTypeId    = LogTypeEnum.Notification,
                        LogDescription = string.Format("Se intentó declinar el usuario {0} del esquema de seguridad, pero ya existe previamente", user.UserId),
                        Application    = new ApplicationPMX
                        {
                            ApplicationName =
                                _applicationName
                        }
                    };
                    var loglogic = new LogLogic(_configuration);
                    loglogic.InsertLogEvent(log);
                    loglogic.Dispose();
                    response.Message = "El usuario ha sido declinado previamente";
                    return(response);
                }
                response.Message = string.Format("Ocurrio un error al intentar declinar el usuario. {0} {1}", err.Message, DateTime.Now.ToString(CultureInfo.InvariantCulture));
                return(response);
            }
            return(response);
        }
        public Response DelApplication(ApplicationPMX application, User registerUser)
        {
            var response = new Response {
                Message = "Sin inicializar.", Result = false
            };
            var applicationDa = new ApplicationDA(_configuration);

            try
            {
                if (application == null)
                {
                    response.Message = "El objeto application no puede ser nulo";
                    return(response);
                }
                if (registerUser == null)
                {
                    response.Message = "El objeto registerUser no puede ser nulo";
                    return(response);
                }

                if (string.IsNullOrEmpty(application.DeclineDate))
                {
                    response.Message = "La fecha fin de vigencia no puede estar vacía.";
                    return(response);
                }

                //Log user
                var userLogic  = new UserLogic(_configuration);
                var userFinded = userLogic.FindUser(registerUser.UserId);
                userLogic.Dispose();

                if (userFinded == null)
                {
                    response.Message = "Usuario no válido para declinar la aplicación.";
                    return(response);
                }
                application.CreationUserId     = registerUser.UserId;
                application.ModificationUserId = registerUser.UserId;

                var log = new Log
                {
                    Application = new ApplicationPMX {
                        ApplicationName = _applicationName
                    },
                    EventUser      = registerUser,
                    EventTypeId    = LogTypeEnum.Notification,
                    LogDescription = string.Format("Declinó la aplicacion {0}-{1} de SeguridadApp. Fecha declinación {2}  ", application.ApplicationId, application.ApplicationName, application.DeclineDate)
                };
                var loglogic = new LogLogic(_configuration);
                loglogic.InsertLogEvent(log);
                loglogic.Dispose();


                applicationDa.DelApplication(application, registerUser);
                response.Message = string.Format("Se declino correctamente la aplicación de SeguridadApp. ");
                response.Result  = true;
            }
            catch (Exception err)
            {
                var log = new Log
                {
                    EventUser      = registerUser,
                    EventTypeId    = LogTypeEnum.Notification,
                    LogDescription = string.Format("Se intentó declinar la aplicacion {0} en SeguridadApp, pero ocurrio un error. {1}", application.ApplicationName, err.Message),
                    Application    = new ApplicationPMX
                    {
                        ApplicationName =
                            _applicationName
                    }
                };
                var loglogic    = new LogLogic(_configuration);
                var responseLog = loglogic.InsertLogEvent(log);
                loglogic.Dispose();

                response.Message = string.Format("Ocurrio un error al intentar declinar una aplicacion. {0} {1}", responseLog.Message, DateTime.Now.ToString(CultureInfo.InvariantCulture));
                response.Result  = false;
            }
            applicationDa.Dispose();
            return(response);
        }
        /// <summary>
        /// Adds application object to application Database
        /// </summary>
        /// <param name="application">Values required ApplicationName,ApplicationDescription, FunctionalUserId, TecnicalUserId,ValidityStartDate</param>
        /// <param name="registerUser">Values required UserId</param>
        /// <returns></returns>
        public Response AddApplication(ApplicationPMX application, User registerUser, object [] args, List <string> cuentasUsuarios)
        {
            var response = new Response {
                Message = "Sin inicializar.", Result = false
            };
            var applicartionDa = new ApplicationDA(_configuration);

            try
            {
                if (application == null)
                {
                    response.Message = "El objeto application no puede ser nulo";
                    return(response);
                }
                if (registerUser == null)
                {
                    response.Message = "El objeto registerUser no puede ser nulo";
                    return(response);
                }
                if (string.IsNullOrEmpty(application.ApplicationName))
                {
                    response.Message = "Debe de proporcionar un nombre a la aplicación.";
                    return(response);
                }

                if (string.IsNullOrEmpty(application.ApplicationDescription) || application.ApplicationDescription.Length < 1)
                {
                    response.Message = "El nombre de la aplicación no puede estar vacía.";
                    return(response);
                }

                var applications = GetApplicationList();
                var appFinded    = applications.Find(app => app.ApplicationName == application.ApplicationName);
                if (appFinded != null)
                {
                    response.Message = "El nombre de la aplicación ya existe registrada en SeguridadApp";
                    return(response);
                }

                //Application paswordHashed
                if (string.IsNullOrEmpty(application.ApplicationPassword) || application.ApplicationPassword.Length < 8)
                {
                    response.Message = "Debe de especificar un password para la aplicación. Longitud mínima 8 caracteres.";
                    return(response);
                }

                /*Mantenimiento pendiente de criptografia de passwords de applicacion*/
                //We use EnterpriseLibrary 5.0 to generate a hashed password and store in db.
                //application.ApplicationPassword = Cryptographer.CreateHash("SecurityAlgorithim", application.ApplicationPassword);
                /*Fin Mantenimieto*/



                if (Convert.ToDateTime(application.ValidityStartDate).Year != DateTime.Now.Year)
                {
                    response.Message = "El año de vigencia de la aplicación no puede ser distinto al año actual";
                    return(response);
                }
                if (string.IsNullOrEmpty(application.Observations))
                {
                    application.Observations = " ";
                }

                if (Convert.ToDateTime(application.ValidityStartDate) > Convert.ToDateTime(application.DeclineDate))
                {
                    response.Message = "La fecha Vigencia final no puede ser menor a la fecha de inicio";
                    return(response);
                }

                //Tecnical user finded
                if (string.IsNullOrEmpty(application.TecnicalUserId))
                {
                    response.Message = "La cuenta del usuario no ha sido registrada previamente.";
                    return(response);
                }
                var userLogic          = new UserLogic(_configuration);
                var userTecnicalFinded = userLogic.FindUser(application.TecnicalUserId);
                userLogic.Dispose();
                if (userTecnicalFinded == null)
                {
                    response.Message = "La cuenta de usuario especificado no ha sido registrado previamente.";
                    return(response);
                }

                //Functional user finded
                if (string.IsNullOrEmpty(application.FunctionalUserId))
                {
                    response.Message = "Es necesario especificar una cuenta de usuario que exista previamente registrada.";
                    return(response);
                }

                var userFunctionalFinded = userLogic.FindUser(application.FunctionalUserId);
                userLogic.Dispose();
                if (userFunctionalFinded == null)
                {
                    response.Message = "La cuenta del usuario especificado no ha sido registrado previamente.";
                    return(response);
                }


                //Log user
                var userFinded = userLogic.FindUser(registerUser.UserId);

                if (userFinded == null)
                {
                    response.Message = "la cuenta de usuario para registrar la aplicación no es válido.";
                    return(response);
                }
                application.CreationUserId     = registerUser.UserId;
                application.ModificationUserId = registerUser.UserId;



                applicartionDa.AddApplication(application, registerUser);
                var log = new Log
                {
                    Application = new ApplicationPMX {
                        ApplicationName = _applicationName
                    },
                    EventUser      = registerUser,
                    EventTypeId    = LogTypeEnum.Notification,
                    LogDescription = string.Format("Agregó la aplicación {0}-{1} en SeguridadApp. Descripción: {2} Vigente: {3} Vigente hasta: {4} responsable funcional {5} , Observaciones {6} ", application.ApplicationId, application.ApplicationName, application.ApplicationDescription, application.ValidityStartDate, application.DeclineDate, application.FunctionalUserId, application.Observations)
                };

                var loglogic = new LogLogic(_configuration);
                loglogic.InsertLogEvent(log);
                loglogic.Dispose();

                foreach (object o in args)
                {
                    applicartionDa.AddApplicationAdministration(application, userFunctionalFinded, true, true, o.ToString());
                }


                if (cuentasUsuarios != null)
                {
                    foreach (string usuario in cuentasUsuarios)
                    {
                        string[] splitUsuario = usuario.Split(new Char[] { ' ' });


                        var logCuentasUsuarios = new Log
                        {
                            Application = new ApplicationPMX {
                                ApplicationName = _applicationName
                            },
                            EventUser      = registerUser,
                            EventTypeId    = LogTypeEnum.Notification,
                            LogDescription = string.Format("Agregó la cuenta " + splitUsuario[0] + " para ejercer sus permisos de SeguridadApp en la aplicación " + application.ApplicationId + "-" + application.ApplicationName)
                        };


                        loglogic.InsertLogEvent(logCuentasUsuarios);
                    }
                }

                loglogic.Dispose();
                response.Message = string.Format("Se agregó correctamente la nueva aplicación al esquema de seguridad. ");
                response.Result  = true;
            }
            catch (Exception err)
            {
                var log = new Log
                {
                    EventUser      = registerUser,
                    EventTypeId    = LogTypeEnum.Notification,
                    LogDescription = string.Format("Se intentó agregar la aplicación {0} en SeguridadApp, pero ocurrio un error. {1}", application.ApplicationName, err.Message),
                    Application    = new ApplicationPMX
                    {
                        ApplicationName =
                            _applicationName
                    }
                };
                var loglogic    = new LogLogic(_configuration);
                var responseLog = loglogic.InsertLogEvent(log);
                loglogic.Dispose();

                response.Message = string.Format("Ocurrio un error al intentar agregar una nueva aplicación. {0} {1}", responseLog.Message, DateTime.Now.ToString(CultureInfo.InvariantCulture));
                response.Result  = false;
            }
            applicartionDa.Dispose();

            return(response);
        }
        public Response AddNewRoleOperation(RoleOperations roleOperations, User registerUser)
        {
            var response = new Response {
                Message = "Sin inicializar", Result = false
            };

            try
            {
                #region logRegister
                var log = new Log
                {
                    Application = new ApplicationPMX
                    {
                        ApplicationName = _applicationName
                    },
                    EventUser   = registerUser,
                    EventTypeId = LogTypeEnum.Notification,

                    /*LogDescription = string.Format("Se ha agregado la operacion {0} al rol {1}.", roleOperations.OperationId, roleOperations.RoleId)*/
                    LogDescription = string.Format("Agregó la operacion Id {0} al rol Id {1} Fecha vigencia: {2}", roleOperations.OperationId, roleOperations.RoleId, roleOperations.DeclineDate)
                };
                #endregion

                #region AddUserDataValidation
                if (roleOperations.RoleId <= 0)
                {
                    response.Message = "El campo role no puede estar vacío";
                    return(response);
                }

                if (roleOperations.OperationId <= 0)
                {
                    response.Message = "El campo Operación no puede estar vacío";
                    return(response);
                }

                if (registerUser == null)
                {
                    response.Message = "No se ha especificado el usuario con permisos para registrar";
                    return(response);
                }


                //Se valida que no exista la prohibición de combinacion de operaciones
                var operationlogic = new OperationLogic(_configuration);
                var role           = new Role {
                    RoleId = roleOperations.RoleId
                };
                Operation      operationB       = operationlogic.GetOperationById(roleOperations.OperationId);
                var            applicationLogic = new ApplicationLogic(_configuration);
                ApplicationPMX application      = applicationLogic.GetApplication(operationB.ApplicationId);
                applicationLogic.Dispose();
                /*Aqui hay que hacer algo*/

                List <Operation> operations = operationlogic.GetOperationRole(role);

                foreach (var operationA in operations)
                {
                    var resultExist = operationlogic.OperationsNotAllowedCombinationExistAndDate(application, operationA, operationB);

                    if (resultExist.Result)
                    {
                        response.Message =
                            "No se puede agregar operación al rol, ya que no está permitida en la combinación de operaciones";
                        return(response);
                    }
                }
                operationlogic.Dispose();


                #endregion
                var loglogic    = new LogLogic(_configuration);
                var responseLog = loglogic.InsertLogEvent(log);
                loglogic.Dispose();


                if (!responseLog.Result)
                {
                    response.Message = string.Format("No se puede insertar en bitácorá el movimiento. {0}", responseLog.Message);
                    return(response);
                }

                //Validamos que no este asignada la operación al role
                var roleLogic    = new RoleLogic(_configuration);
                var lstOperacion = roleLogic.GetRoleOperation(roleOperations.RoleId);
                roleLogic.Dispose();
                var iRes = 0;

                if (lstOperacion.Any(operation => operation.OperationId.Equals(roleOperations.OperationId)))
                {
                    iRes = 1;
                }

                if (iRes <= 0)
                {
                    var roleOperationDa = new RoleOperationDA(_configuration);
                    roleOperationDa.AddNewRoleOperation(roleOperations, registerUser);
                    roleOperationDa.Dispose();
                    response.Message = "Se asocio correctamente la operación {0} al rol {1}";
                    response.Result  = true;
                }
                else
                {
                    response.Message = "La operación ya esta asignada a ese rol, favor de verificar.";
                }
            }
            catch (Exception err)
            {
                if (err.Message.Substring(0, 35) == "Violation of PRIMARY KEY constraint")
                {
                    var log = new Log
                    {
                        EventUser      = registerUser,
                        EventTypeId    = LogTypeEnum.Notification,
                        LogDescription = string.Format("Se intentó asignar la operación al role  {0} en el esquema de seguridad, pero ya existe previamente", roleOperations.RoleId),
                        Application    = new ApplicationPMX
                        {
                            ApplicationName =
                                _applicationName
                        }
                    };
                    var loglogic = new LogLogic(_configuration);
                    loglogic.InsertLogEvent(log);
                    loglogic.Dispose();
                    response.Message = "El rol ha sido registrado previamente";
                    return(response);
                }
                response.Message = string.Format("Ocurrio un error al intentar asignar el rol. {0} {1}", err.Message, DateTime.Now.ToString(CultureInfo.InvariantCulture));
                return(response);
            }
            return(response);
        }
        public Response UpdApplication(ApplicationPMX application, string strpwd, User registerUser, bool canAdminAppRolesAndOperations, bool canAdminUsers, object[] args)
        {
            var response = new Response {
                Message = "Sin inicializar.", Result = false
            };

            var applicationDa = new ApplicationDA(_configuration);

            try
            {
                if (application == null)
                {
                    response.Message = "El objeto application no puede ser nulo";
                    return(response);
                }
                if (registerUser == null)
                {
                    response.Message = "El objeto registerUser no puede ser nulo";
                    return(response);
                }
                if (string.IsNullOrEmpty(application.ApplicationName))
                {
                    response.Message = "Debe de proporcionar un nombre a la aplicación.";
                    return(response);
                }

                if (string.IsNullOrEmpty(application.ApplicationDescription) || application.ApplicationDescription.Length < 1)
                {
                    response.Message = "El nombre de la aplicación no puede estar vacía.";
                    return(response);
                }

                //Application paswordHashed
                if (string.IsNullOrEmpty(application.ApplicationPassword) || application.ApplicationPassword.Length < 8)
                {
                    response.Message = "Debe de especificar un password para la aplicación. Longitud mínima 8 caracteres.";
                    return(response);
                }

                /*Mantenimiento pendiente de criptografia de passwords de applicacion*/
                //We use EnterpriseLibrary 5.0 to generate a hashed password and store in db.
                //if (!strpwd.Trim().Equals(application.ApplicationPassword.Trim()))
                //{
                //    application.ApplicationPassword = Cryptographer.CreateHash("SecurityAlgorithim", application.ApplicationPassword);
                //}


                if (string.IsNullOrEmpty(application.Observations))
                {
                    application.Observations = " ";
                }

                //Tecnical user finded
                if (string.IsNullOrEmpty(application.TecnicalUserId))
                {
                    response.Message = "Es necesario especificar un usuario técnico registrado previamente.";
                    return(response);
                }
                var userLogic          = new UserLogic(_configuration);
                var userTecnicalFinded = userLogic.FindUser(application.TecnicalUserId);
                userLogic.Dispose();
                if (userTecnicalFinded == null)
                {
                    response.Message = "El usuario técnico especificado no ha sido registrado previamente.";
                    return(response);
                }

                //Log user
                var userFinded = userLogic.FindUser(registerUser.UserId);

                if (userFinded == null)
                {
                    response.Message = "El usuario para registrar la aplicación no es válido.";
                    return(response);
                }
                application.CreationUserId     = registerUser.UserId;
                application.ModificationUserId = registerUser.UserId;

                foreach (object o in args)
                {
                    applicationDa.UpdApplication(application, registerUser);
                    applicationDa.UpdApplicationAdministration(application, canAdminAppRolesAndOperations,
                                                               canAdminUsers, o.ToString());
                    response.Message =
                        string.Format("Se Actualizó correctamente la nueva aplicación en SeguridadApp. ");
                    response.Result = true;
                }
                var log = new Log
                {
                    Application = new ApplicationPMX {
                        ApplicationName = _applicationName
                    },
                    EventUser      = registerUser,
                    EventTypeId    = LogTypeEnum.Notification,
                    LogDescription = string.Format("Actualizó la aplicación {0}-{1} en SeguridadApp. Descripción: {2} Vigente {3} Vigente hasta {4} responsable funcional {5} , Observaciones {6} ", application.ApplicationId, application.ApplicationName, application.ApplicationDescription, application.ValidityStartDate, application.DeclineDate, application.FunctionalUserId, application.Observations)
                };
                var loglogic = new LogLogic(_configuration);
                loglogic.InsertLogEvent(log);
                loglogic.Dispose();
            }
            catch (Exception err)
            {
                var log = new Log
                {
                    EventUser      = registerUser,
                    EventTypeId    = LogTypeEnum.Notification,
                    LogDescription = string.Format("Se intentó agregar la aplicacion {0} a SeguridadApp, pero ocurrio un error. {1}", application.ApplicationName, err.Message),
                    Application    = new ApplicationPMX
                    {
                        ApplicationName =
                            _applicationName
                    }
                };
                var loglogic    = new LogLogic(_configuration);
                var responseLog = loglogic.InsertLogEvent(log);
                loglogic.Dispose();

                response.Message = string.Format("Ocurrió un error al intentar agregar una nueva aplicación. {0} {1}", responseLog.Message, DateTime.Now.ToString(CultureInfo.InvariantCulture));
                response.Result  = false;
            }
            applicationDa.Dispose();
            return(response);
        }
        public Response DelRoleOperation(RoleOperations roleOperations, User registerUser)
        {
            var response = new Response {
                Message = "Sin inicializar", Result = false
            };

            try
            {
                #region logRegister
                var log = new Log
                {
                    Application = new ApplicationPMX
                    {
                        ApplicationName = _applicationName
                    },
                    EventUser   = registerUser,
                    EventTypeId = LogTypeEnum.Notification,

                    LogDescription = string.Format("Declinó la operacion Id {0} al rol Id {1} Fecha vigencia: {2}", roleOperations.OperationId, roleOperations.RoleId, roleOperations.DeclineDate)
                };
                #endregion

                #region AddUserDataValidation
                if (roleOperations.RoleId <= 0)
                {
                    response.Message = "El campo role no puede estar vacío";
                    return(response);
                }

                if (roleOperations.OperationId <= 0)
                {
                    response.Message = "El campo Operación no puede estar vacío";
                    return(response);
                }

                if (registerUser == null)
                {
                    response.Message = "No se ha especificado el usuario con permisos para registrar";
                    return(response);
                }
                #endregion

                var loglogic    = new LogLogic(_configuration);
                var responseLog = loglogic.InsertLogEvent(log);
                loglogic.Dispose();
                if (!responseLog.Result)
                {
                    response.Message = string.Format("No se puede insertar en bitácorá el movimiento. {0}", responseLog.Message);
                    return(response);
                }
                var roleOperationDa = new RoleOperationDA(_configuration);
                roleOperationDa.DelRoleOperation(roleOperations, registerUser);
                roleOperationDa.Dispose();
                response.Message = "Se declino correctamente el rol para uso de operaciones.";
                response.Result  = true;
            }
            catch (Exception err)
            {
                if (err.Message.Substring(0, 35) == "Violation of PRIMARY KEY constraint")
                {
                    var log = new Log
                    {
                        EventUser      = registerUser,
                        EventTypeId    = LogTypeEnum.Notification,
                        LogDescription = string.Format("Se intentó agregar al usuario {0} al esquema de seguridad, pero ya existe previamente", roleOperations.RoleId),
                        Application    = new ApplicationPMX
                        {
                            ApplicationName =
                                _applicationName
                        }
                    };
                    var loglogic = new LogLogic(_configuration);
                    loglogic.InsertLogEvent(log);
                    loglogic.Dispose();
                    response.Message = "El usuario ha sido registrado previamente";
                    return(response);
                }
                response.Message = string.Format("Ocurrio un error al intentar agregar el usuario. {0} {1}", err.Message, DateTime.Now.ToString(CultureInfo.InvariantCulture));
                return(response);
            }
            return(response);
        }
        public Response InsertRoleCombinationNotAllowed(ApplicationPMX application, Role roleAc, Role roleBc, User registerUser)
        {
            var response = new Response {
                Message = "Not Initialized", Result = false
            };
            var roleA = this.GetRole(roleAc);
            var roleB = this.GetRole(roleBc);


            if (roleA.RoleId == roleB.RoleId)
            {
                response.Message = "La combinación no puede realizarse con el mismo rol";
                response.Result  = false;
                return(response);
            }

            var resultExist = RoleNotAllowedCombinationExist(application, roleA, roleB);

            if (resultExist.Result)
            {
                response.Message = string.Format("No se puede insertar la combinación de rol.{0}", resultExist.Message);
                response.Result  = false;
                return(response);
            }


            var roleDa = new RoleDA(_configuration);

            try
            {
                roleDa.InsertRoleNotAllowedCombination(application, roleA, roleB, registerUser);
                response.Result  = true;
                response.Message =
                    string.Format(
                        "Se insertó la combinación no permitida del rol {0} y {1} de la aplicación {2}.", roleA.RoleId.ToString() + " " + roleA.RoleName, roleB.RoleId.ToString() + " " + roleB.RoleName, application.ApplicationName);

                #region logRegister
                var log = new Log
                {
                    Application = new ApplicationPMX
                    {
                        ApplicationName = _applicationName
                    },
                    EventUser      = registerUser,
                    EventTypeId    = LogTypeEnum.Notification,
                    LogDescription = response.Message
                };

                #endregion
                var loglogic = new LogLogic(_configuration);
                loglogic.InsertLogEvent(log);
                loglogic.Dispose();
            }
            catch (Exception e)
            {
                response.Message =
                    string.Format(
                        "Ocurrio un error al insertar la combinación de roles. {0}",
                        e.Message);
                response.Result = false;
            }
            roleDa.Dispose();

            return(response);
        }
        public Response AddRoleToApplication(ApplicationPMX application, Role role, User registerUser, int tipo)
        {
            var response = new Response {
                Message = "Sin inicializar", Result = false
            };
            var roleDa = new RoleDA(_configuration);

            try
            {
                //aplicationValidation
                var applicationLogic = new ApplicationLogic(_configuration);
                var applicationList  = applicationLogic.GetApplicationList();
                applicationLogic.Dispose();

                var applicationFinded = applicationList.Find(app => app.ApplicationName == application.ApplicationName);
                if (applicationFinded == null)
                {
                    response.Message = string.Format("La aplicación {0} especificada no existe en el esquema de seguridad", application.ApplicationName);
                    return(response);
                }


                //User validation
                var userLogic  = new UserLogic(_configuration);
                var userFinded = userLogic.FindUser(registerUser.UserId);
                userLogic.Dispose();
                if (userFinded == null)
                {
                    response.Message = string.Format(
                        "El usuario {0} de registro no se encontró en el esquema de seguridad", registerUser.UserId);
                    return(response);
                }

                //Role validation
                var userApplicationRole = new UsersApplicationsRoles()
                {
                    ApplicationId = applicationFinded.ApplicationId
                };

                var roleList          = roleDa.GetRoleforApplication(userApplicationRole, tipo);
                var roleAlreadyFinded = roleList.Find(rolesearched => rolesearched.RoleName == role.RoleName);
                if (roleAlreadyFinded != null)
                {
                    response.Message = string.Format("El nombre {0} del rol no puede ser repetido.", role.RoleName);
                    return(response);
                }
                //TODO:Validar nombre con caracteres distintos
                //Roleregister
                roleDa.AddRole(role, userFinded);

                //LogActivity
                var log = new Log
                {
                    Application = applicationFinded
                    ,
                    EventTypeId = LogTypeEnum.Notification
                    ,
                    EventUser = registerUser
                    ,
                    LogDescription =
                        string.Format("Se agregó el rol {0} a la aplicación {1}.", role.RoleName,
                                      applicationFinded.ApplicationName)
                };
                var loglogic  = new LogLogic(_configuration);
                var resultLog = loglogic.InsertLogEvent(log);
                loglogic.Dispose();
                if (resultLog.Result)
                {
                    response.Message = string.Format("Se agregó el rol {0} a la aplicación {1}.", role.RoleName,
                                                     applicationFinded.ApplicationName);
                    response.Result = true;
                }
                else
                {
                    response.Message = string.Format("Se agregó el rol {0} a la aplicación {1}. Pero no se pudo registrar el movimiento en bitácora.", role.RoleName, applicationFinded.ApplicationName);
                    response.Result  = true;
                }
            }
            catch (Exception err)
            {
                response.Message = string.Format("Ocurrio un error. {0}", err.Message);
            }
            roleDa.Dispose();
            return(response);
        }
        public Response AddNewRole(Role role, User registerUser, int tipo)
        {
            var response = new Response {
                Message = "Sin inicializar", Result = false
            };
            var userDa = new UserDA(_configuration);
            var roleDa = new RoleDA(_configuration);

            try
            {
                #region AddUserDataValidation
                if (role.ApplicationId < 0)
                {
                    response.Message = "El IdAplicación no puede estar vacío";
                    return(response);
                }

                if (string.IsNullOrEmpty(role.RoleName))
                {
                    response.Message = "El campo Nombre no puede estar vacío";
                    return(response);
                }

                if (string.IsNullOrEmpty(role.RoleDescription))
                {
                    response.Message = "El campo descripción no puede estar vacío";
                    return(response);
                }

                if (string.IsNullOrEmpty(role.RoleAuthorizationUserId))
                {
                    response.Message = "El campo autorizador no puede estar vacío";
                    return(response);
                }

                if (string.IsNullOrEmpty(role.RoleAuthorizationOwner))
                {
                    response.Message = "El campo cargo no puede estar vacío";
                    return(response);
                }

                if (registerUser == null)
                {
                    response.Message = "No se ha especificado el usuario con permisos para registrar";
                    return(response);
                }

                var objUser = userDa.FindUser(role.RoleAuthorizationUserId);
                if (objUser == null)
                {
                    response.Message = "La clave del autorizador no es válida o no existe, favor de validar.";
                    return(response);
                }
                #endregion



                //Valida Existencia Role
                var application = new UsersApplicationsRoles
                {
                    ApplicationId = role.ApplicationId,
                    UserId        = registerUser.UserId
                };

                var lstrole = roleDa.GetRoleforApplication(application, tipo);
                var iRes    = 0;

                if (lstrole.Any(roles => roles.RoleName.Equals(role.RoleName)))
                {
                    iRes = 1;
                }

                if (iRes <= 0)
                {
                    roleDa.AddRole(role, registerUser);
                    #region logRegister
                    var log = new Log
                    {
                        Application = new ApplicationPMX
                        {
                            ApplicationName = _applicationName
                        },
                        EventUser      = registerUser,
                        EventTypeId    = LogTypeEnum.Notification,
                        LogDescription = string.Format("Agregó el rol {0}-{1}  a la aplicación id {2}. Vigencia: {3} Autorizador rol: {4} Cargo autorizador:{5} Descripción: {6}",
                                                       role.RoleId, role.RoleName, role.ApplicationId, role.DeclineDate, role.RoleAuthorizationUserId, role.RoleAuthorizationOwner, role.RoleDescription)
                    };



                    #endregion
                    var loglogic = new LogLogic(_configuration);
                    loglogic.InsertLogEvent(log);
                    loglogic.Dispose();
                    response.Message = "Se registró correctamente el rol {0} para la Aplicación {1}";
                    response.Result  = true;
                }
                else
                {
                    response.Message = "Ya esta asignado el rol a la aplicación, favor de verificar.";
                    response.Result  = false;
                }
            }
            catch (Exception err)
            {
                if (err.Message.Substring(0, 35) == "Violation of PRIMARY KEY constraint")
                {
                    var log = new Log
                    {
                        EventUser      = registerUser,
                        EventTypeId    = LogTypeEnum.Notification,
                        LogDescription = string.Format("Se intentó agregar el rol {0} al esquema de seguridad, pero ya existe previamente", role.RoleId),
                        Application    = new ApplicationPMX
                        {
                            ApplicationName = _applicationName
                        }
                    };
                    var loglogic = new LogLogic(_configuration);
                    loglogic.InsertLogEvent(log);
                    loglogic.Dispose();

                    response.Message = "El rol ha sido registrado previamente";
                    return(response);
                }
                response.Message = string.Format("Ocurrio un error al intentar agregar el rol. {0} {1}", err.Message, DateTime.Now.ToString(CultureInfo.InvariantCulture));
                return(response);
            }
            userDa.Dispose();
            roleDa.Dispose();

            return(response);
        }
        public Response DelRole(Role role, User registerUser)
        {
            var response = new Response {
                Message = "Sin inicializar", Result = false
            };

            try
            {
                #region logRegister

                var log = new Log
                {
                    Application = new ApplicationPMX
                    {
                        ApplicationName = _applicationName
                    },
                    EventUser      = registerUser,
                    EventTypeId    = LogTypeEnum.Notification,
                    LogDescription = string.Format("Declinó el rol {0}-{1}  a la aplicación id: {2}. Vigente hasta: {3} Autorizador rol: {4} Cargo autorizador: {5} Descripción: {6}",
                                                   role.RoleId, role.RoleName, role.ApplicationId, role.DeclineDate, role.RoleAuthorizationUserId, role.RoleAuthorizationOwner, role.RoleDescription)
                };

                #endregion

                #region AddUserDataValidation
                if (role.RoleId < 0)
                {
                    response.Message = "La clave del rol no puede estar vacía.";
                    return(response);
                }

                if (role.ApplicationId < 0)
                {
                    response.Message = "La clave de la aplicación no puede estar vacía.";
                    return(response);
                }

                if (registerUser == null)
                {
                    response.Message = "No se ha especificado el usuario con permisos para registrar";
                    return(response);
                }

                #endregion

                var loglogic    = new LogLogic(_configuration);
                var responseLog = loglogic.InsertLogEvent(log);
                loglogic.Dispose();
                if (!responseLog.Result)
                {
                    response.Message = string.Format("No se puede insertar en bitácorá el movimiento. {0}", responseLog.Message);
                    return(response);
                }


                var roleDa = new RoleDA(_configuration);
                roleDa.DelRole(role, registerUser);
                roleDa.Dispose();

                response.Message = "Se declino correctamente el rol para uso de Aplicaciones.";
                response.Result  = true;
            }
            catch (Exception err)
            {
                if (err.Message.Substring(0, 35) == "Violation of PRIMARY KEY constraint")
                {
                    var log = new Log
                    {
                        EventUser      = registerUser,
                        EventTypeId    = LogTypeEnum.Notification,
                        LogDescription = string.Format("Se intentó eliminar el rol {0} al esquema de seguridad, pero ya existe previamente", role.RoleId),
                        Application    = new ApplicationPMX
                        {
                            ApplicationName = _applicationName
                        }
                    };
                    var loglogic = new LogLogic(_configuration);
                    loglogic.InsertLogEvent(log);
                    loglogic.Dispose();
                    response.Message = "El rol ha sido eliminado previamente";
                    return(response);
                }
                response.Message = string.Format("Ocurrio un error al intentar agregar el rol. {0} {1}", err.Message, DateTime.Now.ToString(CultureInfo.InvariantCulture));
                return(response);
            }
            return(response);
        }