public UserList GetUserList(string token, UserSearchCriteria criteria)
 {
     throw new NotImplementedException();
 }
Example #2
0
 /// <summary>
 /// Finds the users matching <paramref name="criteria"/>.
 /// </summary>
 /// <param name="criteria">The criteria.</param>
 /// <returns>The users matching <paramref name="criteria"/>.</returns>
 public List<OptionSourceUser> FindUsers(UserSearchCriteria criteria)
 {
     return this.dataAccess.FindUsers(criteria);
 }
        /// <summary>
        /// Finds the list of users that match the criteria.
        /// </summary>
        /// <param name="filter">Filters the results to only users that match.</param>
        /// <param name="tablesorterMetadata">The tablesorter metadata.</param>
        /// <returns>
        /// The list of users that match the criteria.
        /// </returns>
        protected override UserList DoFindUsers(UserSearchCriteria filter, TablesorterMetadata tablesorterMetadata = null)
        {
            MongoCollection<BsonDocument> collection = this.database.GetCollection(iApplyDb.UserAccess._COLLECTION_NAME);

            QueryDocument outerQuery = new QueryDocument();
            List<IMongoQuery> orQueries = new List<IMongoQuery>();

            if (filter.OrganisationIds != null && filter.OrganisationIds.Any())
            {
                orQueries.AddRange(filter.OrganisationIds.Select(organisationId => Query.Exists(string.Format("{0}.{1}", iApplyDb.UserAccess.ORGANISATIONS, organisationId))));
            }

            if (filter.IncludeNoOrganisationUsers)
            {
                orQueries.Add(Query.NotExists(iApplyDb.UserAccess.ORGANISATIONS));
                orQueries.Add(Query.EQ(iApplyDb.UserAccess.ORGANISATIONS, new BsonDocument()));
            }

            if (!filter.IncludeServiceUsers)
            {
                outerQuery.AddRange(Query.NE(iApplyDb.UserAccess.ACCOUNT_TYPE, new BsonString(AccountType.Service.ToString())).ToBsonDocument());
            }

            if (filter.RoleIds != null && filter.RoleIds.Any())
            {
                orQueries.AddRange(filter.RoleIds.Select(roleId => Query.Exists(string.Format("{0}.{1}", iApplyDb.UserAccess.ROLES, roleId))));
            }

            IMongoQuery subQuery;
            if (orQueries.Count > 0)
            {
                subQuery = Query.Or(orQueries);
                outerQuery.AddRange(subQuery.ToBsonDocument());
            }

            if (filter.UserIds != null && filter.UserIds.Any())
            {
                BsonArray bsonUserIds = new BsonArray();
                bsonUserIds.AddRange(filter.UserIds.Select(u => new BsonObjectId(new ObjectId(u))));
                subQuery = Query.In(iApplyDb.UserAccess._ID, bsonUserIds);
                outerQuery.AddRange(subQuery.ToBsonDocument());
            }

            if (filter.Usernames != null && filter.Usernames.Any())
            {
                BsonArray bsonUserNames = new BsonArray();
                bsonUserNames.AddRange(filter.Usernames.Select(u => new BsonString(u)));
                subQuery = Query.In(iApplyDb.UserAccess.USERNAME, bsonUserNames);
                outerQuery.AddRange(subQuery.ToBsonDocument());
            }

            if (filter.ExternalIds != null && filter.ExternalIds.Any())
            {
                BsonArray bsonExternalIds = new BsonArray();
                bsonExternalIds.AddRange(filter.ExternalIds.Select(u => new BsonString(u)));
                subQuery = Query.In(iApplyDb.UserAccess.EXTERNAL_ID, bsonExternalIds);
                outerQuery.AddRange(subQuery.ToBsonDocument());
            }

            if (tablesorterMetadata != null && tablesorterMetadata.SearchFilters != null)
            {
                for (int i = 0; i < tablesorterMetadata.SearchFilters.Length; i++)
                {
                    var fieldName = tablesorterMetadata.HeaderList[i];
                    var searchTerm = tablesorterMetadata.SearchFilters[i];

                    if (string.IsNullOrWhiteSpace(fieldName) || string.IsNullOrWhiteSpace(searchTerm))
                    {
                        continue;
                    }

                    subQuery = Query.EQ(fieldName, new BsonRegularExpression(searchTerm.Trim(), "i"));
                    outerQuery.AddRange(subQuery.ToBsonDocument());
                }
            }

            MongoCursor<BsonDocument> documents = collection.Find(outerQuery);
            if (tablesorterMetadata != null)
            {
                tablesorterMetadata.TotalRows = Convert.ToInt32(collection.Count(outerQuery));
                documents.SetSkip(tablesorterMetadata.PageSize * tablesorterMetadata.PageIndex).SetLimit(tablesorterMetadata.PageSize);

                if (tablesorterMetadata.SortOrder != null)
                {
                    SortByBuilder newSortByBuilder = new SortByBuilder();
                    foreach (int[] sortCriteria in tablesorterMetadata.SortOrder)
                    {
                        var columnNum = sortCriteria[0];
                        var sortOrder = sortCriteria[1];
                        if (sortOrder == 1)
                        {
                            newSortByBuilder.Descending(tablesorterMetadata.HeaderList[columnNum]);
                        }
                        else
                        {
                            newSortByBuilder.Ascending(tablesorterMetadata.HeaderList[columnNum]);
                        }
                    }

                    documents.SetSortOrder(newSortByBuilder);
                }
            }

            UserList users = BsonConverter.ConvertToObjectViaJson<UserList>(documents);
            return users;
        }
 /// <summary>
 /// Gets the list of users.
 /// </summary>
 /// <param name="token">The security token.</param>
 /// <param name="criteria">The criteria.</param>
 /// <returns>
 /// The list of users.
 /// </returns>
 protected abstract UserList DoGetUserList(string token, UserSearchCriteria criteria = null);
 /// <summary>
 /// Gets the list of users.
 /// </summary>
 /// <param name="token">The security token.</param>
 /// <param name="criteria">The user search criteria.</param>
 /// <returns>
 /// The list of users.
 /// </returns>
 public UserList GetUserList(string token, UserSearchCriteria criteria = null)
 {
     return this.DoGetUserList(token, criteria);
 }
        /// <summary>
        /// Validates the <paramref name="migrationData"/> and returns the results as a list of messages.
        /// </summary>
        /// <param name="migrationData">The migration data to validate.</param>
        /// <returns>A list of warnings resulting from the validation.</returns>
        public MigrationDataResults Validate(MigrationData migrationData)
        {
            MigrationDataResults results = new MigrationDataResults();

            Version currentSystemVersion = this.dataAccess.GetSystemVersion();
            if (migrationData.SystemVersion != null && currentSystemVersion.CompareTo(migrationData.SystemVersion, 2) != 0)
            {
                string message = currentSystemVersion.CompareTo(migrationData.SystemVersion, 2) > 0 ?
                    string.Format(Messages.Validate_TargetSystemVersionTooHigh, currentSystemVersion.ToString(2), migrationData.SystemVersion.ToString(2)) :
                    string.Format(Messages.Validate_TargetSystemVersionTooLow, currentSystemVersion.ToString(2), migrationData.SystemVersion.ToString(2));
                throw new MigrationVersionException(message);
            }

            if (migrationData.SystemVersion == null)
            {
                string message = string.Format(Messages.Validate_ExportMissingVersion, currentSystemVersion.ToString(2));
                throw new MigrationVersionException(message);
            }

            this.ValidateProducts(migrationData, results);

            if (migrationData.Users.Count > 0)
            {
                IEnumerable<string> usernames = migrationData.Users.Select(p => p.Username);
                OrganisationList orgList = this.dataAccess.GetOrganisationList();
                UserSearchCriteria filter = new UserSearchCriteria
                                        {
                                            OrganisationIds = orgList.Select(x => x.Id).ToList(),
                                            Usernames = usernames.ToList()
                                        };
                UserList foundUsers = this.dataAccess.FindUsers(filter);
                foreach (User u in foundUsers)
                {
                    results.AddNotification(migrationData.Users.FirstOrDefault(user => user.Username == u.Username), MessageType.Error, string.Format(Messages.Validate_UserExistsUsername, u.Username));
                }
            }

            if (migrationData.Roles.Count > 0)
            {
                RoleList allRoles = this.dataAccess.GetRoleList();
                foreach (Role r in allRoles.Where(r => !r.SystemDefined))
                {
                    if (migrationData.Roles.Contains(r.Id))
                    {
                        results.AddNotification(r, MessageType.Error, string.Format(Messages.Validate_RoleExistsId, r.RoleName));
                    }
                }
            }

            if (migrationData.Organisations.Count > 0)
            {
                OrganisationList allOrganisations = this.dataAccess.GetOrganisationList();
                foreach (Organisation org in allOrganisations)
                {
                    MigrationOrganisation migrationOrgMatchId = migrationData.Organisations.FirstOrDefault(o => o.Id == org.Id);
                    if (migrationOrgMatchId != null)
                    {
                        results.AddNotification(migrationOrgMatchId, MessageType.Error, string.Format(Messages.Validate_OrgExistsId, org.Name));
                    }
                    else
                    {
                        MigrationOrganisation migrationOrgMatchName = migrationData.Organisations.FirstOrDefault(o => o.Name == org.Name);
                        if (migrationOrgMatchName != null)
                        {
                            results.AddNotification(migrationOrgMatchName, MessageType.Warning, string.Format(Messages.Validate_OrgExistsId, org.Name));
                        }
                    }
                }
            }

            if (migrationData.ServiceEndpoints.Count > 0)
            {
                ServiceEndpointList allEndpoints = this.dataAccess.GetServiceEndpointList();
                foreach (ServiceEndpoint endpoint in allEndpoints)
                {
                    if (migrationData.ServiceEndpoints.Contains(endpoint.Id))
                    {
                        results.AddNotification(endpoint, MessageType.Error, string.Format(Messages.Validate_ServiceEndpointExistsId, endpoint.Name, endpoint.Id));
                    }
                }
            }

            if (migrationData.DataSets.Count > 0)
            {
                GenericDataSetList allDataSets = this.dataAccess.GetDataSetList(false);
                foreach (GenericDataSet dataSet in allDataSets)
                {
                    if (migrationData.DataSets.Any(x => x.Id == dataSet.Id))
                    {
                        results.AddNotification(dataSet, MessageType.Warning, string.Format(Messages.Validate_DataSetExistsId, dataSet.Name, dataSet.Id));
                    }
                }
            }

            return results;
        }
        /// <summary>
        /// Gets the list of users.
        /// </summary>
        /// <param name="token">The security token.</param>
        /// <param name="criteria">The criteria.</param>
        /// <returns>
        /// The list of users.
        /// </returns>
        protected override UserList DoGetUserList(string token, UserSearchCriteria criteria = null)
        {
            criteria = criteria ?? new UserSearchCriteria();

            string jsonString = this.AddTokenAndInvoke(token, new Func<string, string, string>(this.workbenchClient.FindUsers), JsonConvert.SerializeObject(criteria), null);
            string users = JObject.Parse(jsonString).SelectToken("Users").ToString();
            UserList value = JsonConvert.DeserializeObject<UserList>(users);
            return value;
        }
 /// <summary>
 /// Finds the list of users that match the criteria.
 /// </summary>
 /// <param name="filter">Filters the results to only users that match.</param>
 /// <param name="tablesorterMetadata">The tablesorter metadata.</param>
 /// <returns>
 /// The list of users that match the criteria.
 /// </returns>
 public UserList FindUsers(UserSearchCriteria filter, TablesorterMetadata tablesorterMetadata = null)
 {
     return this.DoFindUsers(filter, tablesorterMetadata);
 }
 /// <summary>
 /// Finds the list of users that match the criteria.
 /// </summary>
 /// <param name="filter">Filters the results to only users that match.</param>
 /// <param name="tablesorterMetadata">The tablesorter metadata.</param>
 /// <returns>
 /// The list of users that match the criteria.
 /// </returns>
 protected abstract UserList DoFindUsers(UserSearchCriteria filter, TablesorterMetadata tablesorterMetadata = null);
Example #10
0
        /// <summary>
        /// Updates the users.
        /// </summary>
        /// <param name="session">The session.</param>
        /// <param name="userList">The user list.</param>
        /// <returns>The results of updating the users.</returns>
        public UpdateDataResult UpdateUsers(SessionData session, List<UpdateUser> userList)
        {
            UpdateDataResult results = new UpdateDataResult();

            foreach (UpdateUser updateUser in userList)
            {
                try
                {
                    User existingUser = null;
                    if (!string.IsNullOrEmpty(updateUser.Id))
                    {
                        existingUser = this.workbenchManager.GetUser(session.UserId, updateUser.Id);
                    }
                    else if (!string.IsNullOrEmpty(updateUser.Username))
                    {
                        var search = new UserSearchCriteria
                        {
                            Usernames = new List<string>
                            {
                                updateUser.Username
                            }
                        };
                        UserList users = this.workbenchManager.FindUsers(session.UserId, search);
                        if (users.Count >= 1)
                        {
                            existingUser = users.First();
                        }
                    }

                    if (existingUser == null)
                    {
                        results.AddNotification(updateUser, updateUser.Id ?? updateUser.Username, UpdateMessageType.Error, string.Format(UpdateUserMessages.UserNotFound, updateUser.Username));
                        continue;
                    }

                    bool updatedUserDetails = existingUser.MapUserData(updateUser);
                    RoleList roles = this.workbenchManager.GetRoleList(session.UserId);
                    bool updatedRoles = existingUser.UpdateRoles(updateUser, roles);
                    bool updatedProperties = existingUser.UpdateExtendedProperties(updateUser);

                    if (updatedUserDetails || updatedRoles || updatedProperties)
                    {
                        this.securityService.SaveUser(session, existingUser);
                        results.AddNotification(existingUser, existingUser.Username, UpdateMessageType.Information, string.Format(UpdateUserMessages.Success, existingUser.Username, existingUser.DisplayName));
                    }
                    else
                    {
                        results.AddNotification(existingUser, existingUser.Username, UpdateMessageType.Information, string.Format(UpdateUserMessages.NoChange, existingUser.Username, existingUser.DisplayName));
                    }
                }
                catch (Exception e)
                {
                    results.AddNotification(updateUser, updateUser.Id ?? updateUser.Username, UpdateMessageType.Error, e.Message);
                }
            }

            return results;
        }
Example #11
0
        /// <summary>
        /// Creates a new application in form with ID  <paramref name="formId" /> and sets data contained in 
        /// <paramref name="applicationData" />.
        /// </summary>
        /// <param name="session">An authenticated session object.</param>
        /// <param name="formId">The form id.</param>
        /// <param name="applicationData">The application data to be updated.</param>
        /// <param name="submit">Whether the application should be submitted.</param>
        /// <param name="originator">The application originator to be set.</param>
        /// <returns>
        /// The created application.
        /// </returns>
        public Application CreateApplication(SecureSession session, string formId, ApplicationData applicationData, bool submit, Originator originator)
        {
            Application newApplication = this.formGateway.CreateApplication(session, formId);
            newApplication.ApplicationData = applicationData;

            newApplication = !submit ? this.formGateway.SaveApplication(session, newApplication)
                                : this.formGateway.SubmitApplication(session, newApplication, newApplication.WorkflowState);

            if (originator == null)
            {
                return newApplication;
            }

            UserSearchCriteria filter = new UserSearchCriteria
            {
                IncludeNoOrganisationUsers = true,
                UserIds = new List<string>(),
                Usernames = new List<string>(),
                ExternalIds = new List<string>()
            };

            if (!string.IsNullOrWhiteSpace(originator.Id))
            {
                filter.UserIds.Add(originator.Id);
            }
            else if (!string.IsNullOrWhiteSpace(originator.Username))
            {
                filter.Usernames.Add(originator.Username);
            }
            else if (!string.IsNullOrWhiteSpace(originator.ExternalId))
            {
                filter.ExternalIds.Add(originator.ExternalId);
            }
            else
            {
                return newApplication;
            }

            UserList users = this.workbenchManager.FindUsers(session.AuthenticatedUser.Id, filter);
            User user = users.FirstOrDefault();

            if (user == null)
            {
                return newApplication;
            }

            AuthenticatedApplicationUser originatorUser = new IUserMapper().Map(user, new AuthenticatedApplicationUser());
            newApplication = this.apiDataAccess.UpdateOriginator(newApplication.ApplicationId, originatorUser);
            if (newApplication == null)
            {
                throw new Exception(ExceptionMessages.UpdateOriginatorError);
            }

            return newApplication;
        }
 /// <summary>
 /// Gets the list of users.
 /// </summary>
 /// <param name="token">The security token.</param>
 /// <param name="criteria">The criteria.</param>
 /// <returns>
 /// The list of users.
 /// </returns>
 public UserList GetUserList(string token, UserSearchCriteria criteria = null)
 {
     return this.WrappedGateway.GetUserList(token, criteria);
 }