public List <Role> GetOperationsList(Role roles)
        {
            var lstRole          = new List <Role>();
            var roleOperationDa  = new RoleOperationDA(_configuration);
            var operationDa      = new OperationDA(_configuration);
            var lstRoleoperation = roleOperationDa.GetRoleOperations(roles);

            if (lstRoleoperation.Count > 0)
            {
                var role      = new Role();
                var roleLogic = new RoleLogic(_configuration);
                foreach (var itemroleOperationse in lstRoleoperation)
                {
                    if (role.RoleId != itemroleOperationse.RoleId)
                    {
                        role.RoleId = itemroleOperationse.RoleId;

                        role = roleLogic.GetRole(role);

                        role.OperationsList = new List <Operation>();

                        var lstoperation = operationDa.GetRoleOperations(role);


                        role.OperationsList = lstoperation;

                        lstRole.Add(role);
                    }
                }
                roleLogic.Dispose();
            }
            roleOperationDa.Dispose();
            operationDa.Dispose();

            return(lstRole);
        }
        public Response AddNewUsersApplicationsRoles(UsersApplicationsRoles usersApplicationsRoles, User registerUser)
        {
            var response = new Response {
                Message = "Sin inicializar", Result = false
            };

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

                //Se valida que no exista previamente el rol asignado al usuario
                var usersApplicationsRoleLogic = new UsersApplicationsRolesLogic(_configuration);
                var lstprofileFull             = usersApplicationsRoleLogic.GetApplicationsRoleList(new User()
                {
                    UserId = usersApplicationsRoles.UserId
                }, registerUser);
                usersApplicationsRoleLogic.Dispose();

                var roleFinded = lstprofileFull.Find(a => a.ApplicationName == usersApplicationsRoles.ApplicationName && a.RoleName == usersApplicationsRoles.RoleName);
                if (roleFinded != null)
                {
                    response.Message = "El rol ya ha sido asignado previamente al usuario.";
                    return(response);
                }



                //Se valida que no exista la prohibición de combinacion de roles
                EntityLibrary.ApplicationPMX application = new ApplicationPMX()
                {
                    ApplicationId = usersApplicationsRoles.ApplicationId
                };
                User usertoAdd = new User()
                {
                    UserId = usersApplicationsRoles.UserId
                };
                var roleLogic = new RoleLogic(_configuration);
                List <EntityLibrary.Role> roles = roleLogic.GetRoleList(application, usertoAdd);


                Role roleB = new Role()
                {
                    RoleId = usersApplicationsRoles.RoleId
                };

                foreach (var roleA in roles)
                {
                    var resultExist = roleLogic.RoleNotAllowedCombinationExistAndDate(application, roleA, roleB);
                    if (resultExist.Result)
                    {
                        response.Message =
                            "No se puede agregar el rol al usuario, ya que no está permitida en la combinación de roles";
                        return(response);
                    }
                }
                roleLogic.Dispose();

                if (string.IsNullOrEmpty(usersApplicationsRoles.ApplicationId.ToString()))
                {
                    response.Message = "El campo IdAplicacion no puede estar vacío";
                    return(response);
                }

                if (string.IsNullOrEmpty(usersApplicationsRoles.RoleId.ToString()))
                {
                    response.Message = "El campo IdRole no puede estar vacío";
                    return(response);
                }

                var dateRole = Convert.ToDateTime(usersApplicationsRoles.DeclineDate);
                if (Convert.ToDateTime(string.Format("{0:yyyy/MM/dd}", dateRole)) < Convert.ToDateTime(string.Format("{0:yyyy/MM/dd}", DateTime.Now)))
                {
                    response.Message = "La fecha ingresada no puede ser menor a la fecha actual, favor de verificar.";
                    return(response);
                }

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

                var usersApplicationsRoleDa = new UsersApplicationsRoleDA(_configuration);
                usersApplicationsRoleDa.AddNewUsersApplicationsRoles(usersApplicationsRoles, registerUser);
                usersApplicationsRoleDa.Dispose();
                #region logRegister

                var log = new Log
                {
                    Application = new ApplicationPMX
                    {
                        ApplicationName = _applicationName
                    },
                    EventUser      = registerUser,
                    EventTypeId    = LogTypeEnum.Notification,
                    LogDescription = string.Format("Agregó el rol {0}-{1} de la aplicación {2}-{3} al usuario {4}  Vigente hasta: {5}.",
                                                   usersApplicationsRoles.RoleId, usersApplicationsRoles.RoleName, usersApplicationsRoles.ApplicationId, usersApplicationsRoles.ApplicationName, usersApplicationsRoles.UserId, usersApplicationsRoles.DeclineDate)
                };
                #endregion
                var loglogic = new LogLogic(_configuration);
                loglogic.InsertLogEvent(log);
                loglogic.Dispose();


                response.Message = "Se registró correctamente el rol {0} de la aplicación {1} al userId {2} - {3}.";
                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", registerUser.UserId),
                        Application    = new ApplicationPMX
                        {
                            ApplicationName =
                                _applicationName
                        }
                    };
                    var loglogic = new LogLogic(_configuration);
                    loglogic.InsertLogEvent(log);
                    loglogic.Dispose();
                    response.Message = "El usuario ya cuenta con el role seleccionado.";
                    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);
        }
Esempio n. 3
0
        public Response GetUserInformationAndOperations(User userAuthenticaded, string applicationName, string applicationPassword, out List <Operation> operationUserList)
        {
            var response = new Response {
                Message = "Not initilizated", Result = false
            };

            operationUserList = new List <Operation>();
            try
            {
                //Validate data
                if (userAuthenticaded == null)
                {
                    response.Message = "No se puede enviar el objeto user como nulo.";
                    return(response);
                }
                if (string.IsNullOrEmpty(applicationName))
                {
                    response.Message = "No se puede enviar el nombre de la aplicación como nulo.";
                    return(response);
                }
                if (string.IsNullOrEmpty(applicationPassword))
                {
                    response.Message = "No se puede enviar la contraseña de la aplicación como nulo.";
                    return(response);
                }


                //1.-GetApplication Id
                var applicationLogic  = new ApplicationLogic(_configuration);
                var applicationDbList = applicationLogic.GetApplicationList();
                applicationLogic.Dispose();
                var appFinded = applicationDbList.Find(app => app.ApplicationName == applicationName);
                if (appFinded == null)
                {
                    response.Message = string.Format("La aplicación  {0} especificada no está registrada en esquema de seguridad. {1}", applicationName, DateTime.Now.ToString());
                    return(response);
                }

                if (applicationPassword.Trim() != appFinded.ApplicationPassword.Trim())
                {
                    response.Message = string.Format("La contraseña de aplicación especificada no es válida. {0}", DateTime.Now.ToString());
                    return(response);
                }

                //var applicationPasswordResult = Cryptographer.CompareHash("SecurityAlgorithim", applicationPassword, appFinded.ApplicationPassword);
                //if(!applicationPasswordResult)
                //{
                //    response.Message = string.Format("La contraseña de aplicación especificada no es válida. {0}",DateTime.Now.ToString());
                //    return response;
                //}


                //Using appFinded and user, we search for operations
                var userlogic  = new UserLogic(_configuration);
                var userFinded = userlogic.FindUser(userAuthenticaded.UserId);
                userlogic.Dispose();
                if (userFinded == null)
                {
                    response.Message = string.Format("La cuenta {0} no existe en el esquema de seguridad. {1}", userAuthenticaded.UserId, DateTime.Now.ToString());
                    return(response);
                }
                var         roleLogic   = new RoleLogic(_configuration);
                List <Role> rolesFinded = roleLogic.GetRoleList(appFinded, userFinded);
                roleLogic.Dispose();
                if (rolesFinded.Count == 0)
                {
                    response.Message =
                        string.Format("No ha sido asignado ningún rol al usuario {0} en el esquema de seguridad. {1}", userAuthenticaded.UserId, DateTime.Now.ToString());
                    return(response);
                }



                //validate if User object has a valid sessionId
                var sessionLogic      = new SessionLogic(_configuration);
                var sessionValidation = sessionLogic.ValidateSession(userAuthenticaded, appFinded);
                sessionLogic.Dispose();
                if (!sessionValidation.Result)
                {
                    response.Message = string.Format("Sesión de usuario no válida.  {0}", sessionValidation.Message);
                    return(response);
                }

                var operationLogic = new OperationLogic(_configuration);
                operationUserList = operationLogic.GetOperationList(rolesFinded);
                operationLogic.Dispose();
                response.Result  = true;
                response.Message = string.Format("Se encontraron {0} operaciones para la el usuario {1} y aplicacion {2}. ", operationUserList.Count, userFinded.UserId, appFinded.ApplicationName, DateTime.Now.ToString());
            }
            catch (Exception err)
            {
                response.Message = string.Format("Ocurrio un error al autorizar. {0} {1} ", err.Message, DateTime.Now.ToString());
                return(response);
            }


            return(response);
        }
Esempio n. 4
0
        public Response GetUserInformationAndRoles(string applicationName, string applicationPassword, string userId, out User user, out List <Role> roleUserList)
        {
            var response = new Response {
                Message = "Not initilizated", Result = false
            };

            user         = new User();
            roleUserList = new List <Role>();
            try
            {
                //Validate data
                if (string.IsNullOrEmpty(userId))
                {
                    response.Message = "No se puede enviar el objeto user como nulo.";
                    return(response);
                }
                if (string.IsNullOrEmpty(applicationName))
                {
                    response.Message = "No se puede enviar el nombre de la aplicación como nulo.";
                    return(response);
                }
                if (string.IsNullOrEmpty(applicationPassword))
                {
                    response.Message = "No se puede enviar la contraseña de la aplicación como nulo.";
                    return(response);
                }


                //1.-GetApplication Id
                var applicationLogic  = new ApplicationLogic(_configuration);
                var applicationDbList = applicationLogic.GetApplicationList();
                applicationLogic.Dispose();
                var appFinded = applicationDbList.Find(app => app.ApplicationName == applicationName);
                if (appFinded == null)
                {
                    response.Message = string.Format("La aplicación  {0} especificada no está registrada en esquema de seguridad. {1}", applicationName, DateTime.Now.ToString());
                    return(response);
                }


                if (applicationPassword.Trim() != appFinded.ApplicationPassword.Trim())
                {
                    response.Message = string.Format("La contraseña de aplicación especificada no es válida. {0}", DateTime.Now.ToString());
                    return(response);
                }

                //var applicationPasswordResult = Cryptographer.CompareHash("SecurityAlgorithim", applicationPassword, appFinded.ApplicationPassword);
                //if (!applicationPasswordResult)
                //{
                //    response.Message = string.Format("La contraseña de aplicación especificada no es válida. {0}", DateTime.Now.ToString());
                //    return response;
                //}


                //Using appFinded and user, we search for operations
                var userLogic  = new UserLogic(_configuration);
                var userFinded = userLogic.FindUser(userId);
                userLogic.Dispose();
                if (userFinded == null)
                {
                    response.Message = string.Format("El userId {0} no ha sido registrado en el esquema de seguridad. {1}", userId, DateTime.Now.ToString());
                    return(response);
                }
                //Using user finded and applicationfinded, we look for the user roles.
                var         roleLogic   = new RoleLogic(_configuration);
                List <Role> rolesFinded = roleLogic.GetRoleList(appFinded, userFinded);
                roleLogic.Dispose();
                if (rolesFinded.Count == 0)
                {
                    response.Message =
                        string.Format("No ha sido asignado ningún rol al usuario {0} en el esquema de seguridad. {1}", userId, DateTime.Now.ToString());
                    return(response);
                }

                user         = userFinded;
                roleUserList = rolesFinded;

                StringBuilder sb = new StringBuilder();
                sb.Append("Se encontraron los roles : ");
                foreach (var role in roleUserList)
                {
                    sb.Append(string.Format(" {0}, ", role.RoleName));
                }
                sb.Append(string.Format("para el usuario {0} de la aplicación {1}", user.UserId, appFinded.ApplicationName));
                response.Result  = true;
                response.Message = sb.ToString();
            }
            catch (Exception err)
            {
                response.Message = string.Format("Ocurrio un error al buscar información del usuario. {0} {1} ", err.Message, DateTime.Now.ToString());
                return(response);
            }
            return(response);
        }
Esempio n. 5
0
        /// <summary>
        /// Returns a user List that are contained in the requested role.
        /// </summary>
        /// <param name="applicationName"></param>
        /// <param name="applicationPassword"></param>
        /// <param name="roleName"></param>
        /// <param name="userList"></param>
        /// <returns></returns>
        public Response GetUserListByRole(string applicationName, string applicationPassword, string roleName, out List <User> userList)
        {
            var response = new Response {
                Message = "Not initilizated", Result = false
            };

            userList = new List <User>();
            try
            {
                //1.-GetApplication Id
                var applicationLogic  = new ApplicationLogic(_configuration);
                var applicationDbList = applicationLogic.GetApplicationList();
                applicationLogic.Dispose();
                var appFinded = applicationDbList.Find(app => app.ApplicationName == applicationName);
                if (appFinded == null)
                {
                    response.Message = string.Format("La aplicación  {0} especificada no está registrada en esquema de seguridad. {1}", applicationName, DateTime.Now.ToString());
                    return(response);
                }


                if (applicationPassword.Trim() != appFinded.ApplicationPassword.Trim())
                {
                    response.Message = string.Format("La contraseña de aplicación especificada no es válida. {0}", DateTime.Now.ToString());
                    return(response);
                }

                //var applicationPasswordResult = Cryptographer.CompareHash("SecurityAlgorithim", applicationPassword, appFinded.ApplicationPassword);
                //if (!applicationPasswordResult)
                //{
                //    response.Message = string.Format("La contraseña de aplicación especificada no es válida. {0}", DateTime.Now.ToString());
                //    return response;
                //}
                var         roleLogic           = new RoleLogic(_configuration);
                List <Role> applicationRoleList = roleLogic.GetRoleList(appFinded);
                roleLogic.Dispose();
                var roleFinded = applicationRoleList.Find(rolfinded => rolfinded.RoleName == roleName);
                if (roleFinded == null)
                {
                    response.Message = string.Format("El rol {0} no pudo ser encontrado en la aplicacion {1}", roleName,
                                                     appFinded.ApplicationName);
                    return(response);
                }

                var         usersApplicationsRoleLogic = new UsersApplicationsRolesLogic(_configuration);
                List <User> listRoleUsers         = usersApplicationsRoleLogic.FindRoleUsers(roleFinded, appFinded);
                List <User> listaRoleUserVigentes = new List <User>();
                foreach (var roleUser in listRoleUsers)
                {
                    DateTime declineDate    = Convert.ToDateTime(roleUser.DeclineDate);
                    DateTime declineDateSIO = Convert.ToDateTime(roleUser.DeclineDateSIO);
                    if (declineDate > DateTime.Now && declineDateSIO > DateTime.Now)
                    {
                        listaRoleUserVigentes.Add(roleUser);
                    }
                }

                usersApplicationsRoleLogic.Dispose();

                if (listaRoleUserVigentes.Count == 0)
                {
                    response.Message =
                        string.Format("No pudo ser encontrado ningun usuario para el rol {0} de la aplicación {1}",
                                      roleFinded.RoleName, appFinded.ApplicationName);
                    return(response);
                }

                userList         = listaRoleUserVigentes;
                response.Message = string.Format("Se encontraron {0} usuarios para el rol {1} de la aplicacion {2}",
                                                 userList.Count.ToString(), roleFinded.RoleName,
                                                 appFinded.ApplicationName);
                response.Result = true;
                return(response);

                //UsersApplicationsRolesLogic.GetApplicationsRoleList()
            }
            catch (Exception exception)
            {
                response.Message = string.Format("Ocurrió un error al obtener la lista de usuarios por rol. Error {0}",
                                                 exception.Message);
                response.Result = false;
                return(response);
            }
        }
Esempio n. 6
0
        /// <summary>
        /// Returns a true or false response against Security schema
        /// </summary>
        /// <param name="userAuthenticaded"></param>
        /// <param name="applicationName"></param>
        /// <param name="applicationPassword"></param>
        ///  <param name="operation"></param>
        /// <returns></returns>
        public Response Authorize(User userAuthenticaded, string applicationName, string applicationPassword, string operation)
        {
            var response = new Response {
                Message = "Not initilizated", Result = false
            };

            try
            {
                //Validate data
                if (userAuthenticaded == null)
                {
                    response.Message = "502- Dato obligatorio: Cuenta de usuario.";
                    return(response);
                }
                if (string.IsNullOrEmpty(applicationName))
                {
                    response.Message = "502- Dato obligatorio: Nombre de la aplicación.";
                    return(response);
                }
                if (string.IsNullOrEmpty(applicationPassword))
                {
                    response.Message = "502- Dato obligatorio: Contraseña de la aplicación.";
                    return(response);
                }
                if (string.IsNullOrEmpty(operation))
                {
                    response.Message = "502- Dato obligatorio: Nombre de la operación.";
                    return(response);
                }

                //1.-GetApplication Id
                var applicationLogic  = new ApplicationLogic(_configuration);
                var applicationDbList = applicationLogic.GetApplicationList();
                applicationLogic.Dispose();

                var appFinded = applicationDbList.Find(app => app.ApplicationName == applicationName);
                if (appFinded == null)
                {
                    response.Message = string.Format("700 - La aplicación {0} no existe en SeguridadApp. {1}", applicationName, DateTime.Now.ToString());
                    return(response);
                }
                if (Convert.ToDateTime(appFinded.DeclineDate) < DateTime.Now)
                {
                    response.Message =
                        string.Format(
                            "607 - La aplicacion no se encuentra vigente. Si considera que la aplicación debe estar vigente, repórtelo a la extensión 811-49111.");
                    return(response);
                }

                if (applicationPassword.Trim() != appFinded.ApplicationPassword.Trim())
                {
                    response.Message = string.Format("701 - La contraseña de aplicación es incorrecta. {0}", DateTime.Now.ToString());
                    return(response);
                }

                //var applicationPasswordResult = Cryptographer.CompareHash("SecurityAlgorithim", applicationPassword, appFinded.ApplicationPassword);
                //if(!applicationPasswordResult)
                //{
                //    response.Message = string.Format("La contraseña de aplicación especificada no es válida. {0}",DateTime.Now.ToString());
                //    return response;
                //}


                //Using appFinded and user, we search for operations
                var userLogic  = new UserLogic(_configuration);
                var userFinded = userLogic.FindUser(userAuthenticaded.UserId);
                userLogic.Dispose();

                if (userFinded == null)
                {
                    response.Message = string.Format("500 - La cuenta de usuario {0} no existe en SeguridadApp. {1}", userAuthenticaded.UserId, DateTime.Now.ToString());
                    return(response);
                }
                var         roleLogic   = new RoleLogic(_configuration);
                List <Role> rolesFinded = roleLogic.GetRoleList(appFinded, userFinded);
                roleLogic.Dispose();
                if (rolesFinded.Count == 0)
                {
                    response.Message =
                        string.Format("503 - La cuenta de usuario {0} no tiene roles asignados. {1}", userAuthenticaded.UserId, DateTime.Now.ToString());
                    return(response);
                }
                var operationLogic = new OperationLogic(_configuration);
                var operationsList = operationLogic.GetOperationList(rolesFinded);
                operationLogic.Dispose();
                if (operationsList.Count == 0)
                {
                    var sb = new StringBuilder();
                    sb.Append(string.Format("504 - La cuenta de usuario {0} no tiene operaciones/transacciones asignadas. {1}", userFinded.UserId, DateTime.Now.ToString()));
                    foreach (var role in rolesFinded)
                    {
                        sb.Append(string.Format("Operaciones buscadas para el rol id {0}, nombre rol {1}, d  ", role.RoleId, role.RoleName));
                    }
                    response.Message = sb.ToString();
                    return(response);
                }

                //Search for the Operation specified.
                var operationFinded = operationsList.Find(operationsearched => operationsearched.OperationName == operation);
                if (operationFinded == null)
                {
                    response.Message = string.Format("La operación {0} solicitada, no está registrada en el esquema de seguridad o no está asignada al rol del usuario. {1}", operation, DateTime.Now.ToString());
                    return(response);
                }

                //validate if User object has a valid sessionId
                var sessionLogic      = new SessionLogic(_configuration);
                var sessionValidation = sessionLogic.ValidateSession(userAuthenticaded, appFinded);
                sessionLogic.Dispose();
                if (!sessionValidation.Result)
                {
                    response.Message = string.Format("Sesión de usuario no válida.  {0}", sessionValidation.Message);
                    return(response);
                }



                response.Result  = true;
                response.Message = string.Format("Se validó correctamente la operacion {0} para la el usuario {1} y aplicacion {2}. {3}", operationFinded.OperationName, userFinded.UserId, appFinded.ApplicationName, DateTime.Now.ToString());
            }
            catch (Exception err)
            {
                response.Message = string.Format("Ocurrio un error al autorizar. {0} {1} ", err.Message, DateTime.Now.ToString());
                return(response);
            }


            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);
        }