public MainViewModel( IDataApiClient dataApiClient, LogEntryMonitor logEntryMonitor, IClosable mainWindow) { this.logEntryMonitor = logEntryMonitor; this.mainWindow = mainWindow; logEntryMonitor.NewLogEntry += LogEntryMonitor_NewLogEntry; logEntryMonitor.MonitoringStateChanged += LogEntryMonitor_MonitoringStateChanged; logEntryMonitor.HistoricLogEntriesLoaded += LogEntryMonitor_HistoricLogEntriesLoaded; UserSwitchViewModel = new UserSwitchViewModelFactory( dataApiClient, LoginSuccessful, LoginFailed).Create(); OpenProcessorWindowCommand = new RelayCommand(OpenProcessorWindow, () => SelectedProcessor != null); OpenTaskWindowCommand = new RelayCommand(OpenTaskWindow, () => SelectedTask != null); UpdateTaskPeriodsCommand = new RelayCommand(UpdateTaskPeriod); UpdateExecutionTimesCommand = new RelayCommand(UpdateExecutionTimes); periodUpdateTimer = new Timer(TimeSpan.FromMinutes(5).TotalMilliseconds); periodUpdateTimer.Elapsed += (sender, args) => UpdateTaskPeriod(); executionTimeUpdateTimer = new Timer(TimeSpan.FromMinutes(5).TotalMilliseconds); executionTimeUpdateTimer.Elapsed += (sender, args) => UpdateExecutionTimes(); }
public MainViewModel( IDataApiClient dataApiClient, DataVisualizer dataVisualizer, IReadonlyObjectDatabase <UserProfile> userDatabase, IReadonlyObjectDatabase <DataSet> dataSetDatabase, IReadonlyObjectDatabase <DataProject> dataProjectDatabase, IClipboard clipboard, IClosable mainWindow) { this.dataApiClient = dataApiClient; this.userDatabase = userDatabase; this.mainWindow = mainWindow; DataSetMainViewModel = new DataSetMainViewModel(dataApiClient, dataSetDatabase, dataProjectDatabase, clipboard); CollectionsMainViewModel = new CollectionsMainViewModel(dataApiClient, dataVisualizer, userDatabase, clipboard); var passwordBoxSpawner = new WpfPasswordBoxSpawner(); var loginViewSpawner = new WpfWindowSpawner <LoginViewModel>(vm => new LoginWindow { ViewModel = vm }); var changePasswordViewSpawner = new WpfWindowSpawner <ChangePasswordViewModel>(vm => new ChangePasswordWindow { ViewModel = vm }); UserSwitchViewModel = new UserSwitchViewModel( dataApiClient, LoginSuccessful, LoginFailed, passwordBoxSpawner, loginViewSpawner, changePasswordViewSpawner); OpenUserManagementWindowCommand = new RelayCommand(OpenUserManagementWindow); OpenAboutWindowCommand = new RelayCommand(OpenAboutWindow); }
public ProtocolParameterViewModel( IDataApiClient dataApiClient, IReadonlyObjectDatabase <DataCollectionProtocolParameter> protocolParameterDatabase, DataCollectionProtocolParameter parameter = null) { valueViewModelFactory = new ParameterValueViewModelFactory(dataApiClient); NameAutoCompleteViewModel = new AutoCompleteTextBoxViewModel <DataCollectionProtocolParameter>( x => x.Name, protocolParameterDatabase, new ProtocolParameterAutoCompleteMatcher(), allowNewValue: true, objectBuilder: name => new DataCollectionProtocolParameter(name, null, false, DataCollectionProtocolParameterType.Text)); NameAutoCompleteViewModel.PropertyChanged += NameAutoCompleteViewModel_PropertyChanged; var dataTypes = Task.Run(async() => await dataApiClient.ListCollectionNamesAsync(true)).Result; DataTypeAutoCompleteViewModel = new AutoCompleteTextBoxViewModel <string>( x => x, new FixedSetDatabase <string>(dataTypes.ToDictionary(x => x, x => x)), new StringAutoCompleteMatcher()); DataTypeAutoCompleteViewModel.PropertyChanged += DataTypeAutoCompleteViewModel_PropertyChanged; ValueViewModel = valueViewModelFactory.Create(SelectedParameterType, DataTypeAutoCompleteViewModel.SelectedObject); if (parameter != null) { NameAutoCompleteViewModel.SelectedObject = Task.Run(() => protocolParameterDatabase.GetFromIdAsync(parameter.Id).Result).Result; IsMandatory = parameter.IsMandatory; SelectedParameterType = parameter.Type; DataTypeAutoCompleteViewModel.SelectedObject = parameter.DataType; DefaultValue = parameter.DefaultValue; } }
public GenericDatabaseIntegrationTest() { var apiConfiguration = new ApiConfiguration("", 443); dataApiClient = new DataApiClient(apiConfiguration); dataApiClient.Login(); }
public UserManagementViewModel( IDataApiClient dataApiClient, IReadonlyObjectDatabase <UserProfile> userDatabase) { this.dataApiClient = dataApiClient; try { var userProfileLoader = new UserProfileLoader(dataApiClient, userDatabase); var userProfiles = Task.Run(() => userProfileLoader.LoadAsync()).Result .OrderBy(x => x.Username); UserProfiles = new ObservableCollection <UserProfileViewModel>(userProfiles); } catch (Exception e) { StaticMessageBoxSpawner.Show($"Failed to load user profiles: {e.InnermostException().Message}"); UserProfiles = new ObservableCollection <UserProfileViewModel>(); } CreateUserViewModel = new CreateUserViewModel(userDatabase, dataApiClient); CreateUserViewModel.UserCreated += (sender, userProfile) => UserProfiles.Add(userProfile); SaveUserDetailsCommand = new RelayCommand(SaveUserDetails, () => SelectedUserProfile != null); AddRoleCommand = new RelayCommand(AddRole, CanEditUser); RemoveRoleCommand = new RelayCommand(RemoveRole, CanEditUser); DeleteUserCommand = new RelayCommand(DeleteUser, CanEditUser); }
public UserProfileLoader( IDataApiClient dataApiClient, IReadonlyObjectDatabase <UserProfile> userDatabase) { this.dataApiClient = dataApiClient; this.userDatabase = userDatabase; }
public static List <DataObjectViewModel> BuildItems( List <JObject> searchResults, bool includeMetadata, string dataType, IDataApiClient dataApiClient, IClipboard clipboard, ICollectionSwitcher collectionSwitcher, Action <DataObjectViewModel> deleteCallback) { var dataObjects = new List <DataObjectViewModel>(); var jsonViewModelFactory = new JsonViewModelFactory(clipboard, collectionSwitcher); foreach (var jObject in searchResults) { var id = jObject.ContainsKey("_id") ? jObject["_id"].Value <string>() : null; JToken data = jObject; if (!includeMetadata && jObject.ContainsKey("Data")) { data = jObject["Data"]; } if (!(jsonViewModelFactory.Create(data) is JObjectViewModel jObjectViewModel)) { continue; } var dataObject = new DataObjectViewModel(jObjectViewModel, dataType, id, dataApiClient, deleteCallback); dataObjects.Add(dataObject); } return(dataObjects); }
public ImageFileViewModel( DataReference rawDataReference, IObjectDatabase <ShortId> shortIdDatabase, IDataApiClient dataApiClient) { ShortIdEditViewModel = new ShortIdEditViewModel(rawDataReference, shortIdDatabase, dataApiClient); }
/// <summary> /// Checks collections for sufficient permissions. /// </summary> /// <param name="dataApiClient">DataAPI client</param> /// <param name="requiredCollectionPermissions">Map of required permissions. Data type as key, list of permissions as value.</param> /// <returns> /// Result containing boolean indicating sufficient permissions and, /// if false, the first collection with insufficient permissions, the actual roles and the required roles. /// </returns> public static async Task <DataPermissionCheckerResult> Check( IDataApiClient dataApiClient, Dictionary <string, IList <Role> > requiredCollectionPermissions) { foreach (var kvp in requiredCollectionPermissions) { var collectionName = kvp.Key; var requiredPermissions = kvp.Value; try { var collectionInfomration = await dataApiClient.GetCollectionInformationAsync(collectionName); if (!HashSufficientPermissions(collectionInfomration.UserRoles, requiredPermissions)) { return(DataPermissionCheckerResult.Fail(collectionName, collectionInfomration.UserRoles, requiredPermissions)); } } catch (ApiException apiException) { if (apiException.StatusCode == HttpStatusCode.Unauthorized) { return(DataPermissionCheckerResult.Fail(collectionName, new Role[] {}, requiredPermissions)); } throw; } } return(DataPermissionCheckerResult.Pass()); }
public CollectionSettingsViewModel( CollectionInformation collectionInformation, List <CollectionUserPermissions> collectionPermissions, IDataApiClient dataApiClient, IReadonlyObjectDatabase <UserProfile> userDatabase) { this.dataApiClient = dataApiClient; this.userDatabase = userDatabase; CollectionName = collectionInformation.CollectionName; IsAdmin = collectionInformation.UserRoles.Contains(Role.Admin); IsUserManager = collectionInformation.UserRoles.Intersect(new[] { Role.Admin, Role.UserManager }).Any(); DisplayName = collectionInformation.DisplayName ?? collectionInformation.CollectionName; Description = collectionInformation.Description; SelectedIdGeneratorType = collectionInformation.IdGeneratorType; NonAdminUsersCanOverwriteData = collectionInformation.NonAdminUsersCanOverwriteData; IsProtected = collectionInformation.IsProtected; IsHidden = collectionInformation.IsHidden; var currentUser = dataApiClient.LoggedInUsername; var userPermissionViewModels = BuildUserPermissionsViewModels(collectionInformation, collectionPermissions, currentUser); UserPermissions = new ObservableCollection <UserPermissionsViewModel>(userPermissionViewModels); Validators = collectionInformation.ValidatorDefinitions.Select(x => new ValidatorDefinitionViewModel(x)).ToList(); AddUserCommand = new RelayCommand(AddUser, () => CanEditUserPermissions); DeleteUserCommand = new RelayCommand(DeleteUser, () => CanEditUserPermissions); SaveCommand = new AsyncRelayCommand <IClosable>(Save); CancelCommand = new RelayCommand <IClosable>(closable => closable.Close(false)); }
public QueryEditorViewModel(IDataApiClient dataApiClient, string collectionName) { this.dataApiClient = dataApiClient; CollectionName = collectionName; RunQueryCommand = new AsyncRelayCommand(RunQuery, CanRunQuery); }
private string SubscribeToUnitTestSearchObject(IDataApiClient dataApiClient, params DataModificationType[] modificationTypes) { return(dataApiClient.SubscribeAsync( nameof(UnitTestSearchObject), modificationTypes) .Result); }
public LogTruncationTask( IDataApiClient dataApiClient, TimeSpan logPreservationTimeSpan) { this.dataApiClient = dataApiClient; this.logPreservationTimeSpan = logPreservationTimeSpan; }
public DataObjectLoader( IDataApiClient dataApiClient, IClipboard clipboard, ICollectionSwitcher collectionSwitcher) { this.dataApiClient = dataApiClient; jsonViewModelFactory = new JsonViewModelFactory(clipboard, collectionSwitcher); }
public ImageVisualizationViewModel(IDataApiClient dataApiClient, List <string> imageIds) { this.dataApiClient = dataApiClient; ImageIds = imageIds; ImageCanvas = new ZoomPanCanvasViewModel(); ExportAllCommand = new AsyncRelayCommand(ExportAll); ExportSelectedCommand = new AsyncRelayCommand(ExportSelected, () => SelectedImageId != null); }
public GenericDatabase(IDataApiClient dataApiClient, string collectionName, string permanentFilter = null) { this.dataApiClient = dataApiClient ?? throw new ArgumentNullException(nameof(dataApiClient)); parsedPermanentFilter = permanentFilter; ElementType = typeof(JObject); Provider = new DataApiQueryProvider <JObject>(dataApiClient); Expression = Expression.Constant(this); CollectionName = collectionName ?? throw new ArgumentNullException(nameof(collectionName)); }
public CsvFileViewModel( DataReference csvDataReference, Table <string> data, IObjectDatabase <ShortId> shortIdDatabase, IDataApiClient dataApiClient) { Data = CreateDataGridColumns(data); ShortIdEditViewModel = new ShortIdEditViewModel(csvDataReference, shortIdDatabase, dataApiClient); }
public CollectionListViewModel( IDataApiClient dataApiClient, IReadonlyObjectDatabase <UserProfile> userDatabase) { this.dataApiClient = dataApiClient; this.userDatabase = userDatabase; RefreshCollectionListCommand = new AsyncRelayCommand(Reload); }
public DataReferenceViewModel( [NotNull] DataReference dataReference, [NotNull] IDataApiClient dataApiClient) { Model = dataReference ?? throw new ArgumentNullException(nameof(dataReference)); this.dataApiClient = dataApiClient ?? throw new ArgumentNullException(nameof(dataApiClient)); DownloadCommand = new AsyncRelayCommand(Download); }
public CreateUserViewModel( IReadonlyObjectDatabase <UserProfile> userDatabase, IDataApiClient dataApiClient) { this.userDatabase = userDatabase; this.dataApiClient = dataApiClient; PasswordBox = new PasswordBox(); PasswordRepeatBox = new PasswordBox(); SaveCommand = new RelayCommand(SaveAndClose, CanSave); }
public Distributor( IDataApiClient dataApiClient, ProcessorDatabase processorDatabase, IDataProcessingServiceLogger dataProcessingServiceLogger) { this.dataApiClient = dataApiClient; this.processorDatabase = processorDatabase; this.dataProcessingServiceLogger = dataProcessingServiceLogger; processorRunner = new ProcessorRunner(dataApiClient, dataProcessingServiceLogger); }
public CsvFileHandler( IObjectDatabase <CsvFile> csvFileDatabase, IObjectDatabase <ShortId> shortIdDatabase, IDataApiClient dataApiClient) { this.csvFileDatabase = csvFileDatabase; this.shortIdDatabase = shortIdDatabase; this.dataApiClient = dataApiClient; }
public PeriodicTasksRunner( IDataApiClient dataApiClient, TaskDatabase taskDatabase, IDataProcessingServiceLogger dataProcessingServiceLogger) { this.dataApiClient = dataApiClient; this.taskDatabase = taskDatabase; this.dataProcessingServiceLogger = dataProcessingServiceLogger; taskQueue = InitializeTaskQueue(); }
public static ITrackList Create(int[] trackIds, List <TrackDto> tracks, IDataApiClient apiClient) { if (tracks.Count < trackIds.Length) { return(new TrackListLazyLoading(trackIds, tracks, apiClient)); } else { return(new TrackListSimple(tracks)); } }
public PostponedProcessingRunner( IDataApiClient dataApiClient, IEnumerable <IProcessor> processors, IDataProcessingServiceLogger dataProcessingServiceLogger) : base(nameof(PostponedProcessingRunner), DataApiClient.GetCollectionName <PostponedProcessingObject>()) { this.dataApiClient = dataApiClient; this.dataProcessingServiceLogger = dataProcessingServiceLogger; this.processors = processors.ToDictionary(x => x.DisplayName, x => x); processorRunner = new ProcessorRunner(dataApiClient, dataProcessingServiceLogger); }
public LazyContainer(int[] trackIds, List <TrackDto> tracks, IDataApiClient apiClient) { this.trackIds = trackIds; this.apiClient = apiClient; tracksMap = new Dictionary <int, TrackDto>(); foreach (var track in tracks) { tracksMap[track.Id] = track; } }
public static void DeleteData(IEnumerable <string> ids, IDataApiClient dataApiClient) { var tasks = new List <Task>(); foreach (var id in ids) { var task = dataApiClient.DeleteAsync <UnitTestSearchObject>(id); tasks.Add(task); } Task.WaitAll(tasks.ToArray()); }
public static async Task CreateDataCollectionProtocol( IDataApiClient dataApiClient, string protocolName, List <DataCollectionProtocolParameter> parameters, List <DataPlaceholder> expectedData) { var protocol = new DataCollectionProtocol( protocolName, parameters ?? new List <DataCollectionProtocolParameter>(), expectedData ?? new List <DataPlaceholder>()); await dataApiClient.InsertAsync(protocol, protocolName); }
public static AuthenticationResult RegisterAndLoginUserWithoutRoles(out IDataApiClient dataApiClient) { var username = GenerateUsername(); var password = GeneratePassword(); var email = $"{username}@example.org"; var firstName = "Jamie"; var lastName = "Doe"; dataApiClient = new DataApiClient(ApiSetup.ApiConfiguration); dataApiClient.Register(username, firstName, lastName, password, email); return(dataApiClient.Login(username, password)); }
public CollectionExplorationViewModel( IDataApiClient dataApiClient, CollectionInformation collectionInformation, DataVisualizer dataVisualizer, IClipboard clipboard, ICollectionSwitcher collectionSwitcher) { CollectionInformation = collectionInformation; DataObjectListViewModel = new DataObjectListViewModel(collectionInformation, dataApiClient, dataVisualizer, clipboard, collectionSwitcher); QueryEditorViewModel = new QueryEditorViewModel(dataApiClient, collectionInformation.CollectionName); QueryEditorViewModel.JsonSearchFinished += QueryEditorViewModel_JsonSearchFinished; }