public void UpdateDatasetInclCheckRights() { (DataContext dbContext, UserService userService, UserRepository userRepository, DatasetRepository datasetRepository, DatasetService datasetService) = InitDb("UpdateDataset"); User adminUser = CreateInitialuser(dbContext, "*****@*****.**"); User initialUser = CreateInitialuser(dbContext, "*****@*****.**"); Dataset dataset = CreateInitialXorDataset(dbContext, adminUser, DataSetFlags.Public); DatasetDto datasetDto = new DatasetDto(); datasetDto.Name = "Dataset name changed"; datasetDto.Flags = DataSetFlags.Private; datasetDto.Json = dataset.Data; datasetDto.Id = dataset.Id; datasetService.Update(datasetDto, adminUser.Id); Dataset updatedDataset = dbContext.Datasets.First(x => x.Id == dataset.Id); DatasetDto updatedDatasetDto = new DatasetDto(); updatedDatasetDto.Json = updatedDataset.Data; Assert.AreEqual(datasetDto.Name, updatedDataset.Name); Assert.AreEqual(datasetDto.Flags, updatedDataset.Flags); Assert.ThrowsException <Exception>(() => datasetService.Update(datasetDto, initialUser.Id)); }
public DatasetDto Post(DatasetDto datasetDto) { try { return(_datasetService.Update(datasetDto, UserId.Value)); } finally { DbContext.Dispose(); } }
public async void GetDatasetByIdAsync_ShouldReturnDataset_IfExists() { var datasetId = 10; _ = await ClearTestDatabase(); var datasets = CreateTestDatasetList(datasetId); var datasetService = DatasetServiceMockFactory.GetDatasetService(_serviceProvider, datasets); DatasetDto result = await datasetService.GetByIdAsync(datasetId); Assert.NotNull(result); }
/// <summary> /// Maps a Dataset to a DatasetDto /// </summary> /// <param name="ds">Dataset</param> /// <returns>DatasetDto</returns> public static DatasetDto ToDto(Dataset ds) { if (ds != null) { DatasetDto dto = new DatasetDto(); dto.Name = ds.Name; dto.Flags = ds.Flags; dto.Id = ds.Id; dto.Json = ds.Data; dto.UserId = ds.UserId; dto.User = ds.User; return(dto); } return(null); }
protected void PerformUsualTestForPostedDatasets(DatasetDto datasetDto) { if (String.IsNullOrWhiteSpace(datasetDto.Name)) { throw new ArgumentException($"Field Dataset.Name is required. Current value: {datasetDto.Name}"); } if (String.IsNullOrWhiteSpace(datasetDto.Classification)) { throw new ArgumentException($"Field Dataset.Classification is required. Current value: {datasetDto.Classification}"); } if (String.IsNullOrWhiteSpace(datasetDto.Location)) { throw new ArgumentException($"Field Dataset.Location is required. Current value: {datasetDto.Location}"); } }
public async Task <IActionResult> Post(int?id, [FromBody] DatasetDto dataset) { if (id == null || id <= 0) { return(NotFound()); } if (ModelState.IsValid) { Project projectToUpdate = await context.Projects .SingleOrDefaultAsync(p => p.ProjectId == id); if (projectToUpdate == null) { return(NotFound()); } Dataset mappedDataset = mapper.Map <Dataset>(dataset); Dataset datasetToUpdate = await context.Datasets .SingleOrDefaultAsync(d => d.ProjectId == id); if (datasetToUpdate == null) { datasetToUpdate = new Dataset(); datasetToUpdate.ProjectId = id ?? default(int); datasetToUpdate.Data = mappedDataset.Data; context.Datasets.Add(datasetToUpdate); } else { datasetToUpdate.Data = mappedDataset.Data; } projectToUpdate.DateUpdated = DateTime.Now; await context.SaveChangesAsync(); return(Ok(mapper.Map <DatasetDto>(datasetToUpdate))); } return(BadRequest(ModelState)); }
/// <summary> /// Checks the right for the update process and updates the dataset and /// </summary> /// <param name="datasetDto">dataset</param> /// <param name="userId">userid</param> /// <returns>the updated dataset</returns> public DatasetDto Update(DatasetDto datasetDto, int userId) { ValidateDataset(datasetDto); Dataset result = null; if (datasetDto.Id > 0) { Dataset ds = _datasetRepository.GetById(datasetDto.Id); ds.Data = datasetDto.Json; ds.Flags = datasetDto.Flags; ds.Name = datasetDto.Name; ds.Modified = DateTime.Now; if (ds.UserId != userId) { throw new Exception("No permission to update this dataset."); } _datasetRepository.DataContext.Commit(); result = ds; } else { Dataset ds = new Dataset() { Id = 0, Name = datasetDto.Name, Flags = datasetDto.Flags, Data = datasetDto.Json, UserId = userId, Created = DateTime.Now, Modified = DateTime.Now }; _datasetRepository.Add(ds); _datasetRepository.DataContext.Commit(); result = ds; } return(DatasetMapper.ToDto(result)); }
/// <summary> /// Validates the dataset /// </summary> /// <param name="dataset">dataset</param> public void ValidateDataset(DatasetDto dataset) { DatasetEnvelopeDto datasetEnvelope = dataset.Dataset; if (string.IsNullOrEmpty(dataset.Name)) { throw new Exception("Please enter a name for the provided dataset."); } else { if (_datasetRepository.GetByName(dataset.Name) != null && dataset.Id < 1) { throw new Exception("A dataset with this name already exists."); } } if (datasetEnvelope.Items.Length > 0) { int inputLength = datasetEnvelope.Items.FirstOrDefault()?.Data?.Length ?? throw new Exception("First item entry has no 'Data' attribute"); int outputLength = datasetEnvelope.Items.FirstOrDefault()?.Labels?.Length ?? throw new Exception("First item entry has no 'Label' attribute"); foreach (DataItemDto item in datasetEnvelope.Items) { if (item.Labels == null || item.Data == null) { throw new Exception($"Item entry {(Array.IndexOf(datasetEnvelope.Items, item) + 1)} must have a label and a data attribute."); } if (item.Data.Length < 1) { throw new Exception($"Item {(Array.IndexOf(datasetEnvelope.Items, item) + 1)} 'Data' attribute must have length > 0"); } if (item.Labels.Length < 1) { throw new Exception($"Item {(Array.IndexOf(datasetEnvelope.Items, item) + 1)} 'Labels' attribute must have length > 0"); } if (item.Data.Length != inputLength) { throw new Exception($"Dataset is not consistent. Item number {(Array.IndexOf(datasetEnvelope.Items, item) + 1)} " + $" 'Data' attribute has a different length ({item.Data.Length}) than the first Item ({inputLength})"); } if (item.Labels.Length != outputLength) { throw new Exception($"Dataset is not consistent. Item number {(Array.IndexOf(datasetEnvelope.Items, item) + 1)} " + $" 'Label' attribute has a different length ({item.Labels.Length}) than the first Item ({outputLength})"); } if (datasetEnvelope.ProblemType.ToLower() == "classification") { bool foundOne = false; foreach (int label in item.Labels) { if (label == 1d && foundOne) { throw new Exception($"Item number {(Array.IndexOf(datasetEnvelope.Items, item) + 1)} is not one-hot encoded. Two '1' found."); } if (label == 1d) { foundOne = true; } if (label != 0d && label != 1d) { throw new Exception($"Item number {(Array.IndexOf(datasetEnvelope.Items, item) + 1)} is not one-hot encoded. Only '0' and '1's are allowed."); } } if (!foundOne) { throw new Exception($"Item number {(Array.IndexOf(datasetEnvelope.Items, item) + 1)} is not one-hot encoded. No '1' was found."); } } } } else { throw new Exception("No Items found!"); } if (datasetEnvelope.OutputDescription != null && datasetEnvelope.OutputDescription.Length > 0) { if (datasetEnvelope.Items.First().Labels.Length != datasetEnvelope.OutputDescription.Length) { throw new Exception("'OutputDescription' must have the same number of descriptions like there are Outputneurons / Label entries."); } if (datasetEnvelope.ProblemType.ToLower() == "regression") { throw new Exception("'OutputDescription' only possible with problem type 'classification'."); } } if (datasetEnvelope.Layers != null && datasetEnvelope.Layers.Length > 0) { if (datasetEnvelope.Layers.Length < 2) { throw new Exception("If you want to provide layers, you must provide at least two layers (input and outputlayer)"); } LayerDto inputLayer = datasetEnvelope.Layers.First(); if (!string.IsNullOrEmpty(inputLayer.Activation) || inputLayer.Bias) { throw new Exception("Inputlayer can not have an activation Function or a Bias!"); } if (datasetEnvelope.Items.First().Data.Length != datasetEnvelope.Layers.First().Neurons) { throw new Exception($"Inputlayer must have same number of neurons like the length of the data input ({datasetEnvelope.Items.First().Data.Length})"); } if (datasetEnvelope.Items.First().Labels.Length != datasetEnvelope.Layers.Last().Neurons) { throw new Exception($"Outputlayer must have same number of neurons like the length of the label ({datasetEnvelope.Items.First().Labels.Length})"); } for (int i = 0; i < datasetEnvelope.Layers.Length; i++) { LayerDto layer = datasetEnvelope.Layers[i]; if (layer.Neurons < 1) { throw new Exception($"Layer {i + 1} must have a positive number of neurons"); } if (!string.IsNullOrEmpty(layer.Activation) && i != 0) { if (!new List <string>() { "relu", "sigmoid", "tanh", "softmax", "linear" }.Contains(layer.Activation.ToLower())) { throw new Exception($"Layer {i + 1} activation function must have value 'linear', 'relu', 'sigmoid', 'softmax' or 'tanh'"); } } } } if (datasetEnvelope.Matrix != null && datasetEnvelope.Matrix.Length > 0) { if (datasetEnvelope.Matrix.Length != 2) { throw new Exception("Please enter two numbers [rows, columns] for the Matrix Property"); } else { int length = datasetEnvelope.Matrix[0] * datasetEnvelope.Matrix[1]; if (length != datasetEnvelope.Items.First().Data.Length) { throw new Exception($"The vector of the matrix must have the same length like the data input vector which is {datasetEnvelope.Items.First().Data.Length}."); } } } if (datasetEnvelope.TrainingSettings != null) { if (!string.IsNullOrEmpty(datasetEnvelope.TrainingSettings.Optimizer)) { if (!new List <string>() { "rmsprop", "adam", "sgd", "sgdm" }.Contains(datasetEnvelope.TrainingSettings.Optimizer.ToLower())) { throw new Exception("TrainingSetting Optimizer must have value 'rmsprop', 'adam', 'sgd' or 'sgdm'"); } if (!new List <string>() { "rmsprop", "sgdm" }.Contains(datasetEnvelope.TrainingSettings.Optimizer.ToLower()) && datasetEnvelope.TrainingSettings.Momentum.HasValue) { throw new Exception("Momentum only possible with Optimizer 'rmsprop' or 'sgdm'"); } } if (!string.IsNullOrEmpty(datasetEnvelope.TrainingSettings.Loss)) { if (!new List <string>() { "mse", "sce" }.Contains(datasetEnvelope.TrainingSettings.Loss.ToLower())) { throw new Exception("TrainingSetting Loss must have value 'mse' (=mean squared error) or 'sce' (=softmax cross entropy)."); } } } if (!string.IsNullOrEmpty(datasetEnvelope.ProblemType)) { if (!new List <string>() { "classification", "regression" }.Contains(datasetEnvelope.ProblemType.ToLower())) { throw new Exception("ProblemType must have value 'Classification' or 'Regression' "); } } else { throw new Exception("Problemtype [Regression, Classification] required!"); } }
public async Task <DatasetDto> UpdateAsync(int datasetId, DatasetDto updatedDataset) { var datasetFromDb = await _preApprovedDatasetModelService.GetByIdAsync(datasetId, UserOperation.PreApprovedDataset_Create_Update_Delete); PerformUsualTestForPostedDatasets(updatedDataset); if (!String.IsNullOrWhiteSpace(updatedDataset.Name) && updatedDataset.Name != datasetFromDb.Name) { datasetFromDb.Name = updatedDataset.Name; } if (!String.IsNullOrWhiteSpace(updatedDataset.Location) && updatedDataset.Location != datasetFromDb.Location) { datasetFromDb.Location = updatedDataset.Location; } if (!String.IsNullOrWhiteSpace(updatedDataset.Classification) && updatedDataset.Classification != datasetFromDb.Classification) { datasetFromDb.Classification = updatedDataset.Classification; } if (!String.IsNullOrWhiteSpace(updatedDataset.StorageAccountName) && updatedDataset.StorageAccountName != datasetFromDb.StorageAccountName) { datasetFromDb.StorageAccountName = updatedDataset.StorageAccountName; } if (updatedDataset.LRAId != datasetFromDb.LRAId) { datasetFromDb.LRAId = updatedDataset.LRAId; } if (updatedDataset.DataId != datasetFromDb.DataId) { datasetFromDb.DataId = updatedDataset.DataId; } if (updatedDataset.SourceSystem != datasetFromDb.SourceSystem) { datasetFromDb.SourceSystem = updatedDataset.SourceSystem; } if (updatedDataset.BADataOwner != datasetFromDb.BADataOwner) { datasetFromDb.BADataOwner = updatedDataset.BADataOwner; } if (updatedDataset.Asset != datasetFromDb.Asset) { datasetFromDb.Asset = updatedDataset.Asset; } if (updatedDataset.CountryOfOrigin != datasetFromDb.CountryOfOrigin) { datasetFromDb.CountryOfOrigin = updatedDataset.CountryOfOrigin; } if (updatedDataset.AreaL1 != datasetFromDb.AreaL1) { datasetFromDb.AreaL1 = updatedDataset.AreaL1; } if (updatedDataset.AreaL2 != datasetFromDb.AreaL2) { datasetFromDb.AreaL2 = updatedDataset.AreaL2; } if (updatedDataset.Tags != datasetFromDb.Tags) { datasetFromDb.Tags = updatedDataset.Tags; } if (updatedDataset.Description != datasetFromDb.Description) { datasetFromDb.Description = updatedDataset.Description; } datasetFromDb.Updated = DateTime.UtcNow; Validate(datasetFromDb); await _db.SaveChangesAsync(); return(await GetByIdAsync(datasetFromDb.Id)); }
public void DatasetValidationTest() { (DataContext dbContext, UserService userService, UserRepository userRepository, DatasetRepository datasetRepository, DatasetService datasetService) = InitDb("DatasetValidationTest"); User adminUser = CreateInitialuser(dbContext, "*****@*****.**"); DatasetDto dsDto = GetXorDatasetDto(DataSetFlags.Private); datasetService.ValidateDataset(dsDto); //One hot encoding dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Items.First().Labels = new double[] { 0d, 0d }; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Items.First().Labels = new double[] { 1d, 1d }; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Items.First().Labels = new double[] { 2d, 0d }; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Items.First().Labels = new double[] { 0d }; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); // Labels and Data defined dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Items.First().Labels = null; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Items.First().Data = null; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Items.Last().Labels = null; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Items.Last().Data = null; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); // Outputdescription dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.OutputDescription = new string[] { "class 1" }; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.OutputDescription = new string[] { "class 1", "class 2" }; datasetService.ValidateDataset(dsDto); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.OutputDescription = null; datasetService.ValidateDataset(dsDto); // Layer Definition dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Layers.Last().Neurons = 5; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Layers.First().Neurons = 1; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Layers = new LayerDto[] { new LayerDto() { Neurons = 3 } }; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Layers[1].Neurons = 0; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Layers[1].Activation = "Unknown"; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Layers[1].Activation = ""; datasetService.ValidateDataset(dsDto); //Matrix dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Matrix = new int[] { 1, 2 }; datasetService.ValidateDataset(dsDto); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Matrix = new int[] { 2, 2 }; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.Matrix = null; datasetService.ValidateDataset(dsDto); // Training definition dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.TrainingSettings.Loss = ""; datasetService.ValidateDataset(dsDto); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.TrainingSettings.Loss = "Unknown"; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.TrainingSettings.Optimizer = ""; datasetService.ValidateDataset(dsDto); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.TrainingSettings.Optimizer = "Unknown"; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); //Problem Type dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.ProblemType = "Unknown"; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Dataset.ProblemType = ""; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); // Name dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Name = ""; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); CreateInitialXorDataset(dbContext, adminUser, DataSetFlags.Private); dsDto = GetXorDatasetDto(DataSetFlags.Private); dsDto.Name = "XOR"; Assert.ThrowsException <Exception>(() => datasetService.ValidateDataset(dsDto)); //already exists }
public async Task <IActionResult> UpdateAsync(int id, DatasetDto dataset) { var updatedDataset = await _datasetService.UpdateAsync(id, dataset); return(new JsonResult(updatedDataset)); }
/// <summary> /// Configures the needed services for the webapp and creates the initial data for the database /// </summary> /// <param name="services">servicecollection</param> public void ConfigureServices(IServiceCollection services) { services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme) .AddCookie(options => { options.LoginPath = "/Login/UserLogin/"; options.Cookie.Expiration = TimeSpan.FromDays(14); options.Cookie.HttpOnly = true; }); services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1); if (_env.IsEnvironment("Development")) { ConnectionString = Configuration.GetConnectionString("DevelopmentDb"); } else if (_env.IsEnvironment("Test")) { ConnectionString = Configuration.GetConnectionString("TestDb"); } else if (_env.IsEnvironment("Production")) { ConnectionString = Configuration.GetConnectionString("ProductionDb"); } else { throw new Exception("Environment not defined."); } using (DataContext dbContext = DataContextFactory.GetDataContext(ConnectionString)) { DbCreator.CreateDbIfNotExist(dbContext, _env.IsEnvironment("Development")); UserService userService = new UserService(new UserRepository(dbContext)); DatasetService dsService = new DatasetService(new DatasetRepository(dbContext)); if (Configuration.GetValue <bool>("RegenerateStaticDatasets")) { DatasetDto xor = dsService.GetByName(XorDataset); DatasetDto dice = dsService.GetByName(DiceDataset); DatasetDto or = dsService.GetByName(OrDataset); DatasetDto numbers = dsService.GetByName(NumbersDataset); DatasetDto validationNumbers = dsService.GetByName(ValidationNumbersDataset); DatasetDto letters = dsService.GetByName(LettersDataset); if (xor != null) { dsService.Delete(xor.Id, xor.UserId); } if (dice != null) { dsService.Delete(dice.Id, dice.UserId); } if (or != null) { dsService.Delete(or.Id, or.UserId); } if (numbers != null) { dsService.Delete(numbers.Id, numbers.UserId); } if (validationNumbers != null) { dsService.Delete(validationNumbers.Id, validationNumbers.UserId); } if (letters != null) { dsService.Delete(letters.Id, letters.UserId); } } foreach (UserDto user in GetInitialUsers()) { try { userService.Create(user); } catch { }; } dbContext.SaveChanges(); foreach (DatasetDto dsDto in GetInitalDatasets(dbContext.Users.First().Id)) { try { dsService.Update(dsDto, dbContext.Users.First().Id); } catch (Exception ex) { }; } } }
/// <summary> /// Gets the list of the inital datasets /// </summary> /// <param name="userId">userid which creates the dataset</param> /// <returns>list of datasets</returns> private List <DatasetDto> GetInitalDatasets(int userId) { List <DatasetDto> datasets = new List <DatasetDto>(); string location = System.Reflection.Assembly.GetEntryAssembly().Location; string directory = System.IO.Path.GetDirectoryName(location); DatasetDto xorDataset = new DatasetDto() { Json = File.ReadAllText($"{directory}/xor.json"), Flags = DataSetFlags.Public, UserId = userId, Name = XorDataset }; DatasetDto diceDataset = new DatasetDto() { Json = File.ReadAllText($"{directory}/dice.json"), Flags = DataSetFlags.Public, UserId = userId, Name = DiceDataset }; DatasetDto orDataset = new DatasetDto() { Json = File.ReadAllText($"{directory}/or.json"), Flags = DataSetFlags.Public, UserId = userId, Name = OrDataset }; DatasetDto numbersDataset = new DatasetDto() { Json = File.ReadAllText($"{directory}/numbers.json"), Flags = DataSetFlags.Public, UserId = userId, Name = NumbersDataset }; DatasetDto letters = new DatasetDto() { Json = File.ReadAllText($"{directory}/letters.json"), Flags = DataSetFlags.Public, UserId = userId, Name = LettersDataset }; DatasetDto numbersValidation = new DatasetDto() { Json = File.ReadAllText($"{directory}/numbers_validation.json"), Flags = DataSetFlags.Public, UserId = userId, Name = ValidationNumbersDataset }; DatasetDto lettersValidation = new DatasetDto() { Json = File.ReadAllText($"{directory}/letters_validation.json"), Flags = DataSetFlags.Public, UserId = userId, Name = ValidationLettersDataset }; datasets.Add(xorDataset); datasets.Add(diceDataset); datasets.Add(orDataset); datasets.Add(numbersDataset); datasets.Add(letters); datasets.Add(numbersValidation); datasets.Add(lettersValidation); return(datasets); }