public UserProfileLoader(
IDataApiClient dataApiClient,
IReadonlyObjectDatabase <UserProfile> userDatabase)
{
this.dataApiClient = dataApiClient;
this.userDatabase = userDatabase;
}
public AutoCompleteTextBoxViewModel(
Func <T, string> displayNameFunc,
IReadonlyObjectDatabase <T> objectDatabase,
IAutoCompleteMatcher <T> autoCompleteMatcher,
uint maxSuggestions = 10,
bool allowNewValue = false,
Func <string, T> objectBuilder = null)
{
if (allowNewValue && objectBuilder == null)
{
throw new ArgumentNullException(nameof(objectBuilder), "Object builder must be set, if new values are allowed");
}
this.displayNameFunc = displayNameFunc;
this.objectDatabase = objectDatabase;
this.autoCompleteMatcher = autoCompleteMatcher;
this.maxSuggestions = maxSuggestions;
AcceptsNewValues = allowNewValue;
this.objectBuilder = objectBuilder;
updateSuggestionsTimer = new Timer(state => UpdateSuggestions());
SelectNextCommand = new RelayCommand(SelectNextSuggestion);
SelectPreviousCommand = new RelayCommand(SelectPreviousSuggestion);
CloseSuggestionsCommand = new RelayCommand(() => ShowSuggestions = false);
SetBorderBrush();
}
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 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 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 ProjectSelectionViewModel(IReadonlyObjectDatabase <DataProject> projectDatabase)
{
ProjectAutoCompleteViewModel = new AutoCompleteTextBoxViewModel <DataProject>(
x => x.Id,
projectDatabase,
new DataProjectAutoCompleteMatcher());
}
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 UserSelectionViewModel(IReadonlyObjectDatabase <UserProfile> userDatabase)
{
UserAutoCompleteViewModel = new AutoCompleteTextBoxViewModel <UserProfile>(
x => $"{x.FirstName} {x.LastName} ({x.Username})",
userDatabase,
new UserAutoCompleteMatcher());
OkCommand = new RelayCommand <IClosable>(SaveAndClose, CanSave);
CancelCommand = new RelayCommand <IClosable>(closable => closable.Close(false));
}
public async Task <IEnumerable <string> > FindMatches(
IReadonlyObjectDatabase <string> objectDatabase,
string searchText,
uint maxSuggestions)
{
return((await objectDatabase.GetManyAsync())
.Where(str => Match(str, searchText))
.Take((int)maxSuggestions));
}
public async Task <IEnumerable <TDataServiceDefinition> > FindMatches(
IReadonlyObjectDatabase <TDataServiceDefinition> objectDatabase,
string searchText,
uint maxSuggestions)
{
var query = $"Data.Id LIKE '%{searchText}%'";
return(await objectDatabase.GetManyAsync(query, limit : maxSuggestions));
}
public CollectionListViewModel(
IDataApiClient dataApiClient,
IReadonlyObjectDatabase <UserProfile> userDatabase)
{
this.dataApiClient = dataApiClient;
this.userDatabase = userDatabase;
RefreshCollectionListCommand = new AsyncRelayCommand(Reload);
}
public async Task <IEnumerable <DataSet> > FindMatches(
IReadonlyObjectDatabase <DataSet> objectDatabase,
string searchText,
uint maxSuggestions)
{
var normalizedSearchText = SearchTextNormalizer.Normalize(searchText);
var searchQuery = $"Data.{nameof(DataSet.Id)} LIKE '%{normalizedSearchText}%'";
return(await objectDatabase.GetManyAsync(searchQuery, limit : maxSuggestions));
}
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 async Task <IEnumerable <UserProfile> > FindMatches(
IReadonlyObjectDatabase <UserProfile> objectDatabase,
string searchText,
uint maxSuggestions)
{
var allUserProfiles = await objectDatabase.GetManyAsync(); // User profile SQL queries is not supported
// and hence we have to do the search ourself
return(allUserProfiles.Where(user => Match(user, searchText)));
}
public async Task <IEnumerable <DataCollectionProtocolParameter> > FindMatches(
IReadonlyObjectDatabase <DataCollectionProtocolParameter> objectDatabase,
string searchText,
uint maxSuggestions)
{
var normalizedSearchText = SearchTextNormalizer.Normalize(searchText);
var query = $"Data.Name LIKE '%{normalizedSearchText}%'";
return(await objectDatabase.GetManyAsync(query, limit : maxSuggestions));
}
public Task <IEnumerable <JObject> > FindMatches(
IReadonlyObjectDatabase <JObject> objectDatabase,
string searchText,
uint maxSuggestions)
{
var normalizedSearchText = SearchTextNormalizer.Normalize(searchText);
var query = $"Data.Id LIKE '%{normalizedSearchText}%'";
return(objectDatabase.GetManyAsync(query, limit: maxSuggestions));
}
public CollectionsMainViewModel(
IDataApiClient dataApiClient,
DataVisualizer dataVisualizer,
IReadonlyObjectDatabase <UserProfile> userDatabase,
IClipboard clipboard)
{
this.dataApiClient = dataApiClient;
this.dataVisualizer = dataVisualizer;
this.clipboard = clipboard;
collectionSwitcher = new CollectionSwitcher(SwitchToCollection, Constants.DefaultQuery);
CollectionListViewModel = new CollectionListViewModel(dataApiClient, userDatabase);
CollectionListViewModel.PropertyChanged += CollectionListViewModel_PropertyChanged;
}
public CollectionViewModel(
CollectionInformation collectionInformation,
IDataApiClient dataApiClient,
IReadonlyObjectDatabase <UserProfile> userDatabase)
{
CollectionInformation = collectionInformation;
this.dataApiClient = dataApiClient;
this.userDatabase = userDatabase;
Permission = TranslatePermission(collectionInformation.UserRoles);
CanEditCollectionSettings = collectionInformation.UserRoles.Intersect(new[] { Role.UserManager, Role.Admin }).Any();
OpenCollectionSettingsWindowCommand = new AsyncRelayCommand(OpenCollectionSettingsWindow, () => CanEditCollectionSettings);
}
public DataSetMainViewModel(
IDataApiClient dataApiClient,
IReadonlyObjectDatabase <DataSet> dataSetDatabase,
IReadonlyObjectDatabase <DataProject> projectDatabase,
IClipboard clipboard)
{
this.dataApiClient = dataApiClient;
this.dataSetDatabase = dataSetDatabase;
this.projectDatabase = projectDatabase;
this.clipboard = clipboard;
DataSetAutoCompleteViewModel = new AutoCompleteTextBoxViewModel <DataSet>(
x => x.Id,
dataSetDatabase,
new DataSetAutoCompleteMatcher());
DataSetAutoCompleteViewModel.PropertyChanged += DataSetAutoCompleteViewModel_PropertyChanged;
ProjectAutoCompleteViewModel = new AutoCompleteTextBoxViewModel <DataProject>(
x => x.Id,
projectDatabase,
new DataProjectAutoCompleteMatcher());
ProjectAutoCompleteViewModel.PropertyChanged += ProjectAutoCompleteViewModel_PropertyChanged;
LoadDataSetListCommand = new AsyncRelayCommand(LoadDataSetList);
LoadDataProjectListCommand = new AsyncRelayCommand(LoadDataProjectList);
}
