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