public void ShouldFetchDatasetFile() { var datasetFile = Helper.NewDatasetFile(); DatasetFile file = new DatasetService().GetDatasetFile(datasetFile); file.Title.Should().Be("GML-format, 0101, Halden"); }
public void ShouldFetchDatasetFiles() { var download = Helper.NewDownload(); List <DatasetFile> files = new DatasetService().GetDatasetFiles(download); files.Count.Should().BeGreaterThan(1); }
public void Setup() { TestDatabase = new TestDatabase(); Context = new AppDbContext(TestDatabase.ContextOptions); Context.AddTestData(); DS = new DatasetService( new DatasetRepository(Context), new NotificationService(new NotificationRepository(Context), new UnitOfWork(Context)), new PublisherRepository(Context), new CategoryRepository(Context), new CoordinationRepository(Context), new TagsRepository(Context), new UnitOfWork(Context), new MemoryCache(new MemoryCacheOptions()), new GitlabService(new SoullessGitlabCLient(), new Microsoft.Extensions.Configuration.ConfigurationBuilder().Build()) /* * f**k C# som ikke har anonyme implementasjoner av interfaces (wtf liksom? vi lever i en sivilisert verden, ikke koding anno 1999) * og hele dette clusterfucket av dependency injections som er totalt uegnet både på kort og lang sikt ... * Til og med singletons - eller gud forby - statiske klassemetoder, hadde vært mer oversiktlig og lettere å implementere enn dette * stakkarslige systemet med services som later som om de kan genereres automagisk med dependency injection, men likevel * må initialiseres med andre services ... som igjen må initialiseres ... * Hva er grunnen til å skrive "objektorientert" igjen??? Ett av verdens største mysterier ... */); ExampleV = new Dataset { Id = 104, Title = "ExampleV", Identifier = "/api/datasets/104", Description = "Lorem Ipsum", PublicationStatus = EPublicationStatus.notPublished, AccessLevel = EAccessLevel.green, PublisherId = 101, CategoryId = 100 }; }
public void GetDatasetFilesAsViewModel() { var dataset = Helper.NewDataset(); List <DatasetFileViewModel> files = new DatasetService().GetDatasetFiles(dataset); files.Count.Should().BeGreaterThan(1); }
public DatasetsController() { db = new ApplicationDbContext(); datasetRepository = new DatasetRepository(db); discretizationRepository = new DiscretizationRepository(db); datasetService = new DatasetService(datasetRepository); securityService = new SecurityService(datasetRepository, db); id = datasetRepository.GetNextId(); }
public DatasetController(DatasetDescriptorService descriptorService, DatasetService datasetservice, FileService fileService, DataMatrixLoader dataMatrixLoader) { _datasetDescriptorService = descriptorService; _datasetService = datasetservice; _dataMatrixLoader = dataMatrixLoader; _fileService = fileService; }
public KarmaLegoController() { db = new ApplicationDbContext(); datasetRepository = new DatasetRepository(db); klRepository = new KLRepository(db); discretizationService = new DiscretizationService(); karmaLegoService = new KarmaLegoService(); datasetService = new DatasetService(datasetRepository); securityService = new SecurityService(datasetRepository, db); }
/// <summary> /// Creates the initial dbcontext, services and repositories /// </summary> /// <param name="dbName">Database name for the in memory database</param> /// <returns>DbContext, Userservice, UserRepository, DatasetRepository, DatasetService</returns> private static (DataContext, UserService, UserRepository, DatasetRepository, DatasetService) InitDb(string dbName) { DataContext dbContext = new DataContext(DataContextFactory.GetInMemoryDb(dbName)); UserRepository userRep = new UserRepository(dbContext); UserService userService = new UserService(userRep); DatasetRepository datasetRepository = new DatasetRepository(dbContext); DatasetService datasetService = new DatasetService(datasetRepository); return(dbContext, userService, userRep, datasetRepository, datasetService); }
public DatasetTests() { var dbOptions = new DbContextOptionsBuilder <SocNetContext>().UseSqlite("Data Source=tests.db").Options; this.db = new SocNetContext(dbOptions); this.db.Database.EnsureCreated(); var repository = new DatasetRepository(this.db, new DbConfiguration()); this.datasetService = new DatasetService(repository); }
public void RemoveDuplicatesIterative() { List <Download> downloadListWithDoplicates = new List <Download>(); downloadListWithDoplicates.Add(new Download()); downloadListWithDoplicates.Add(new Download()); var result = new DatasetService().RemoveDuplicatesIterative(downloadListWithDoplicates); result.Count.Should().Be(1); }
public static void Main(string[] args) { Log.Logger = new LoggerConfiguration() .MinimumLevel.Information() .WriteTo.File("log-.txt", rollOnFileSizeLimit: true, shared: true, flushToDiskInterval: TimeSpan.FromSeconds(1)) .CreateLogger(); Log.Information("Start Geonorge - nedlaster"); Console.WriteLine("Geonorge - nedlaster"); Console.WriteLine("--------------------"); var appSettings = ApplicationService.GetAppSettings(); if (args.Any()) { Log.Debug("Selected config file(s): "); foreach (var configName in args) { Log.Debug(configName); } foreach (var configName in args) { Log.Debug("Download from selected config-file: " + configName); var config = appSettings.GetConfigByName(configName); if (config != null) { DeleteOldLogs(config.LogDirectory); StartDownloadAsync(config).Wait(); } else { Log.Error("Could not find config file: " + configName); Console.WriteLine("Error: Could not find config file: " + configName); } } } else { Log.Debug("No config file is selected. Download from all config-files"); var datasetService = new DatasetService(appSettings.LastOpendConfigFile); datasetService.ConvertDownloadToDefaultConfigFileIfExists(); foreach (var config in appSettings.ConfigFiles) { StartDownloadAsync(config).Wait(); } } }
public async Task RegenerateProviderSourceDatasets_GivenSpecificationId_ThenCallJobServiceToProcess() { // Arrange IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues> { { "specificationId", new StringValues(SpecificationId) }, }); HttpRequest request = Substitute.For <HttpRequest>(); request.Query.Returns(queryStringValues); IDatasetRepository datasetRepository = CreateDatasetsRepository(); datasetRepository .GetDefinitionSpecificationRelationshipsByQuery(Arg.Any <Expression <Func <DefinitionSpecificationRelationship, bool> > >()) .Returns(new List <DefinitionSpecificationRelationship> { new DefinitionSpecificationRelationship { DatasetVersion = new DatasetRelationshipVersion { Id = "DSRV1", Version = 1 }, Specification = new Common.Models.Reference { Id = SpecificationId, Name = "SpecAbc" } } }); datasetRepository .GetDatasetsByQuery(Arg.Any <Expression <Func <Dataset, bool> > >()) .Returns(new List <Dataset> { new Dataset { Id = "DS1" } }); IJobsApiClient jobsApiClient = CreateJobsApiClient(); DatasetService service = CreateDatasetService(datasetRepository: datasetRepository, jobsApiClient: jobsApiClient); // Act await service.RegenerateProviderSourceDatasets(request); // Assert await jobsApiClient .Received(1) .CreateJob(Arg.Is <JobCreateModel>(j => j.JobDefinitionId == "MapDatasetJob" && j.Properties.ContainsKey("session-id") && j.Properties["session-id"] == SpecificationId)); }
private void CmbConfigFiles_OnSelectionChanged(object sender, SelectionChangedEventArgs e) { var cmbConfig = (ComboBox)sender; if (cmbConfig?.SelectedItem != null) { SaveDownloadList(); _datasetService = new DatasetService(_appSettings.GetConfigByName(cmbConfig.SelectedItem.ToString())); _appSettings.LastOpendConfigFile = _appSettings.GetConfigByName(cmbConfig.SelectedItem.ToString()); ApplicationService.WriteToAppSettingsFile(_appSettings); _selectedFilesForDownload = _datasetService.GetSelectedFilesToDownloadAsViewModel(); LbSelectedFilesForDownload.ItemsSource = _selectedFilesForDownload; } }
public string Download(DatasetIndexViewModel datasetIndexViewModel) { var datasetsRecords = datasetIndexViewModel.DatasetsRecords; var discretizationsRecords = datasetIndexViewModel.DiscretizationsRecords; var karmaLegoRecords = datasetIndexViewModel.KarmaLegoRecords; var discretistationFileHandler = new Discretistation.FileHandler(); Dictionary <int, string> idToParameters = new Dictionary <int, string>(); Dictionary <int, bool> idToRawFlag = new Dictionary <int, bool>(); DatasetService datasetService = new DatasetService(datasetRepository); List <string> allParamsToSend = new List <string>(); if (datasetsRecords != null) { foreach (var datasetRecord in datasetsRecords) { Dataset dataset = datasetRepository.Get(Int32.Parse(datasetRecord)); allParamsToSend.Add(dataset.Path); dataset.NumberOfDownloads += 1; datasetRepository.Edit(dataset); datasetRepository.SaveChanges(); } } if (discretizationsRecords != null) { foreach (var discretizationsRecord in discretizationsRecords) { var discretization = discretizationRepository.Get(Int32.Parse(discretizationsRecord)); var dataset = discretization.Dataset; var datasetPath = dataset.Path; allParamsToSend.Add(discretization.DownloadPath); } } if (karmaLegoRecords != null) { foreach (var karmaLegoRecord in karmaLegoRecords) { var kl = db.KarmaLegos.Find(Int32.Parse(karmaLegoRecord)); var discretization = kl.Discretization; var datasetPath = discretization.Dataset.Path; allParamsToSend.Add(kl.DownloadPath); } } var allParamsToSendString = String.Join(" ", allParamsToSend); return(allParamsToSendString); }
public bool Process() { DatasetService datasetService = new DatasetService(ConnectionString); DataTable dataTable = datasetService.GetDataSetAndDSFieldDefinitionList(); DataTable datasetItemsDT = new DataTable(); bool result = false; var DatasetIDs = dataTable.AsEnumerable().Select(s => s.Field <int>("DatasetId")).Distinct().ToList(); if (DatasetIDs.Any()) { foreach (var dSId in DatasetIDs) { try { var subDataTable = dataTable.AsEnumerable().Where(x => x.Field <int>("DatasetId") == dSId); var datasetName = subDataTable.Where(x => x.Field <int>("DatasetId") == dSId).Select(x => x["DSDescription"]).FirstOrDefault().ToString(); var datasetFieldDefinitions = subDataTable.AsEnumerable().Where(x => x.Field <int>("DatasetId") == dSId).Select(x => new { DFFieldName = x["DFFieldName"], DFDescription = x["DFDescription"] }).ToList(); var fieldNames = datasetFieldDefinitions.Select(x => x.DFFieldName).ToList(); var descriptionNames = datasetFieldDefinitions.Select(x => x.DFDescription).ToList(); int count = datasetFieldDefinitions.Count(); string dynamicQuery = string.Empty; int i = 0; while (count > i) { dynamicQuery += " DI." + fieldNames[i] + " as " + descriptionNames[i] + ","; i++; } dynamicQuery = dynamicQuery.Substring(0, dynamicQuery.Length - 1); datasetItemsDT = datasetService.GetDatasetItemByDatasetId(dynamicQuery, dSId); result = datasetService.GenerateFile(datasetItemsDT, datasetName); Console.WriteLine("Excel file created for Dataset = {0} with dataSetId = {1}", datasetName, dSId); } catch (Exception ex) { throw ex; } } } return(result); }
public DownloadUsageDialog() { InitializeComponent(); _appSettings = ApplicationService.GetAppSettings(); _datasetService = new DatasetService(_appSettings.LastOpendConfigFile); _config = _appSettings.TempConfigFile ?? _appSettings.LastOpendConfigFile; try { _downloadUsageGroup = _datasetService.FetchDownloadUsageGroups(); } catch (Exception e) { _downloadUsageGroup = _datasetService.ReadFromDownloadUsageGroup(); } try { _downloadUsagePurposes = _datasetService.FetchDownloadUsagePurposes(); } catch (Exception e) { _downloadUsagePurposes = _datasetService.ReadFromDownloadUsagePurposes(); } if (_config.DownloadUsageIsSet()) { Group = _config.DownloadUsage.Group; Purpose = _config.DownloadUsage.Purpose; } _downloadUsagePurposesViewModel = new List <PurposeViewModel>(); foreach (var item in _downloadUsagePurposes) { _downloadUsagePurposesViewModel.Add(new PurposeViewModel(item, Purpose)); } cmbDownloadUsageGroups.ItemsSource = _downloadUsageGroup; cmbDownloadUsageGroups.SelectedItem = Group; lbPurposes.ItemsSource = _downloadUsagePurposesViewModel; //lbPurposes.SelectedValue = Purpose; }
public async Task RegenerateProviderSourceDatasets_GivenSpecificationId_ThenCallJobServiceToProcess() { // Arrange IDatasetRepository datasetRepository = CreateDatasetsRepository(); datasetRepository .GetDefinitionSpecificationRelationshipsByQuery(Arg.Any <Expression <Func <DocumentEntity <DefinitionSpecificationRelationship>, bool> > >()) .Returns(new List <DefinitionSpecificationRelationship> { new DefinitionSpecificationRelationship { DatasetVersion = new DatasetRelationshipVersion { Id = "DSRV1", Version = 1 }, Specification = new Common.Models.Reference { Id = SpecificationId, Name = "SpecAbc" } } }); datasetRepository .GetDatasetsByQuery(Arg.Any <Expression <Func <DocumentEntity <Dataset>, bool> > >()) .Returns(new List <Dataset> { new Dataset { Id = "DS1" } }); IJobManagement jobManagement = CreateJobManagement(); DatasetService service = CreateDatasetService(datasetRepository: datasetRepository, jobManagement: jobManagement); // Act await service.RegenerateProviderSourceDatasets(SpecificationId, null, null); // Assert await jobManagement .Received(1) .QueueJob(Arg.Is <JobCreateModel>(j => j.JobDefinitionId == "MapDatasetJob" && j.Properties.ContainsKey("session-id") && j.Properties["session-id"] == SpecificationId)); }
public MainWindow() { InitializeComponent(); BtnSelectAll.Visibility = Visibility.Hidden; BtnSelectAll.IsChecked = false; _datasetService = new DatasetService(); try { LbDatasets.ItemsSource = _datasetService.GetDatasets(); } catch (Exception) { MessageBox.Show("Klarer ikke hente datasett... Sjekk internett tilkoblingen din"); } try { _projections = _datasetService.FetchProjections(); } catch (Exception e) { _projections = _datasetService.ReadFromProjectionFile(); } var viewDatasets = (CollectionView)CollectionViewSource.GetDefaultView(LbDatasets.ItemsSource); if (viewDatasets != null) { viewDatasets.Filter = UserDatasetFilter; } _selectedFiles = _datasetService.GetSelectedFilesAsViewModel(_projections); LbSelectedFiles.ItemsSource = _selectedFiles; _selectedDatasetFiles = new List <DatasetFileViewModel>(); }
public MainWindow() { Log.Logger = new LoggerConfiguration() .MinimumLevel.Information() .WriteTo.File("log-.txt", rollOnFileSizeLimit: true, shared: true, flushToDiskInterval: TimeSpan.FromSeconds(1)) .CreateLogger(); Log.Information("Start application"); InitializeComponent(); BtnSelectAll.Visibility = Visibility.Hidden; BtnSelectAll.IsChecked = false; ToggleSubscribeSelectedDatasetFiles.Visibility = Visibility.Hidden; MenuSubscribe.Visibility = Visibility.Hidden; var massivNedlastingVersjon = new MassivNedlastingVersion(new GitHubReleaseInfoReader()); _currentVersion = MassivNedlastingVersion.Current; if (massivNedlastingVersjon.UpdateIsAvailable()) { versionStatusMessage.Visibility = Visibility.Visible; versionStatusMessage.Text = "Ny versjon tilgjengelig!"; } else { versionStatusMessage.Visibility = Visibility.Collapsed; } _appSettings = ApplicationService.GetAppSettings(); _datasetService = new DatasetService(_appSettings.LastOpendConfigFile); _selectedConfigFile = _appSettings.LastOpendConfigFile; _datasetService.UpdateProjections(); _datasetService.ConvertDownloadToDefaultConfigFileIfExists(); try { LbDatasets.ItemsSource = _datasetService.GetDatasets(); fylker.ItemsSource = _datasetService.GetCounties(); } catch (Exception) { MessageBox.Show("Klarer ikke hente datasett... Sjekk internett tilkoblingen din"); } _selectedFilesForDownload = _datasetService.GetSelectedFilesToDownloadAsViewModel(); _selectedDatasetFiles = new List <DatasetFileViewModel>(); var viewDatasets = (CollectionView)CollectionViewSource.GetDefaultView(LbDatasets.ItemsSource); if (viewDatasets != null) { viewDatasets.Filter = UserDatasetFilter; } LbSelectedFilesForDownload.ItemsSource = _selectedFilesForDownload; cmbConfigFiles.ItemsSource = ApplicationService.NameConfigFiles(); cmbConfigFiles.SelectedItem = _selectedConfigFile.Name; SetDownloadUsage(); RunWatch(); }
private static async Task StartDownloadAsync() { DatasetService datasetService; if (userpath.Length > 1) { datasetService = new DatasetService(userpath); } else { datasetService = new DatasetService(); } List <DatasetFile> datasetToDownload = datasetService.GetSelectedFiles(); List <DatasetFile> updatedDatasetToDownload = new List <DatasetFile>(); DownloadLog downloadLog = new DownloadLog(); downloadLog.TotalDatasetsToDownload = datasetToDownload.Count; var appSettings = applicationService.GetAppSettings(); long totalSizeUpdatedFiles = 0; var downloader = new FileDownloader(); foreach (var localDataset in datasetToDownload) { var fileLog = new DatasetFileLog(localDataset); try { Console.WriteLine(localDataset.DatasetId + " - " + localDataset.Title); DirectoryInfo downloadDirectory = GetDownloadDirectory(appSettings, localDataset); DatasetFile datasetFromFeed = datasetService.GetDatasetFile(localDataset); DownloadHistory downloadHistory = datasetService.GetFileDownloaHistory(datasetFromFeed.Url); bool newDatasetAvailable = NewDatasetAvailable(downloadHistory, datasetFromFeed, downloadDirectory); if (newDatasetAvailable) { Console.WriteLine("Updated version of dataset is available."); } if (newDatasetAvailable) { Console.WriteLine("Starting download process."); downloader.ProgressChanged += (totalFileSize, totalBytesDownloaded, progressPercentage) => { fileLog.HumanReadableSize = HumanReadableBytes(totalFileSize.Value); totalSizeUpdatedFiles += totalFileSize.Value; Console.CursorLeft = 0; Console.Write($"{progressPercentage}% ({HumanReadableBytes(totalBytesDownloaded)}/{HumanReadableBytes(totalFileSize.Value)}) "); // add som extra whitespace to blank out previous updates }; var downloadRequest = new DownloadRequest(localDataset.Url, downloadDirectory, localDataset.IsRestricted()); localDataset.FilePath = await downloader.StartDownload(downloadRequest, appSettings); Console.WriteLine(); downloadLog.Updated.Add(fileLog); updatedDatasetToDownload.Add(localDataset); } else { fileLog.Message = "Not necessary to download dataset."; downloadLog.NotUpdated.Add(fileLog); Console.WriteLine("Not necessary to download dataset."); localDataset.FilePath = downloadHistory.FilePath; updatedDatasetToDownload.Add(localDataset); } } catch (Exception e) { updatedDatasetToDownload.Add(localDataset); fileLog.Message = "Error while downloading dataset: " + e.Message; downloadLog.Faild.Add(fileLog); Console.WriteLine("Error while downloading dataset: " + e.Message); } Console.WriteLine("-------------"); } downloadLog.TotalSizeOfDownloadedFiles = HumanReadableBytes(totalSizeUpdatedFiles); datasetService.WriteToDownloadLogFile(downloadLog); datasetService.WriteToDownloadFile(updatedDatasetToDownload); datasetService.WriteToDownloadHistoryFile(updatedDatasetToDownload); }
public FileController(FileService fileService, DatasetService datasetService, IHostingEnvironment env) { _fileService = fileService; _datasetService = datasetService; _environment = env; }
public void ShouldFetchDatasetFromGeonorge() { List <Dataset> datasets = new DatasetService().GetDatasets(); datasets.Count.Should().BeGreaterThan(1); }
public void FetchDownloadUsagePurposes() { List <string> purposes = new DatasetService().FetchDownloadUsagePurposes(); purposes.Count.Should().BeGreaterThan(1); }
public void FetchDownloadUsageGroups() { List <string> userGroups = new DatasetService().FetchDownloadUsageGroups(); userGroups.Count.Should().BeGreaterThan(1); }
public void FetchProjections() { List <Projections> projections = new DatasetService().FetchProjections(); projections.Count.Should().BeGreaterThan(1); }
public FileController(FileService fileService, DatasetService datasetService) { _fileService = fileService; _datasetService = datasetService; }
private static async Task StartDownloadAsync(ConfigFile config) { var appSettings = ApplicationService.GetAppSettings(); var datasetService = new DatasetService(config); var updatedDatasetToDownload = new List <Download>(); var downloadLog = new DownloadLog(); var downloader = new FileDownloader(); var datasetToDownload = datasetService.GetSelectedFilesToDownload(); var downloadUsage = config.DownloadUsage; downloadLog.TotalDatasetsToDownload = datasetToDownload.Count; foreach (var localDataset in datasetToDownload) { var updatedDatasetFileToDownload = new List <DatasetFile>(); if (localDataset.Subscribe) { Log.Information("Subscribe to Dataset files"); var datasetFilesFromFeed = datasetService.GetDatasetFiles(localDataset); var filterDatasetFromFeed = datasetFilesFromFeed.Where(p => localDataset.Projections.Where(s => s.Selected == false).All(p2 => p2.Epsg != p.Projection)).ToList(); if (localDataset.AutoDeleteFiles) { Log.Debug("Delete files"); localDataset.Files = RemoveFiles(filterDatasetFromFeed, localDataset.Files, config); } if (localDataset.AutoAddFiles) { Log.Debug("Add new files"); localDataset.Files = AddFiles(filterDatasetFromFeed, localDataset.Files); } } foreach (var datasetFile in localDataset.Files) { var fileLog = new DatasetFileLog(datasetFile); try { Console.WriteLine(datasetFile.DatasetId + " - " + datasetFile.Title); DirectoryInfo downloadDirectory = GetDownloadDirectory(config, datasetFile); DatasetFile datasetFromFeed = datasetService.GetDatasetFile(datasetFile); DownloadHistory downloadHistory = datasetService.GetFileDownloaHistory(datasetFile.Url); bool newDatasetAvailable = NewDatasetAvailable(downloadHistory, datasetFromFeed, downloadDirectory); if (newDatasetAvailable) { Console.WriteLine("Updated version of dataset is available."); Console.WriteLine("Starting download process."); downloader.ProgressChanged += (totalFileSize, totalBytesDownloaded, progressPercentage) => { Console.CursorLeft = 0; Console.Write($"{progressPercentage}% ({HumanReadableBytes(totalBytesDownloaded)}/{HumanReadableBytes(totalFileSize.Value)}) "); // add som extra whitespace to blank out previous updates }; var downloadRequest = new DownloadRequest(datasetFile.Url, downloadDirectory, datasetFile.IsRestricted()); datasetFile.FilePath = await downloader.StartDownload(downloadRequest, appSettings); downloadLog.Updated.Add(fileLog); Console.WriteLine(); downloadUsage?.Entries.Add(new DownloadUsageEntries(datasetFile)); updatedDatasetFileToDownload.Add(datasetFile); } else { fileLog.Message = "Not necessary to download dataset." + datasetFromFeed.LastUpdated; downloadLog.NotUpdated.Add(fileLog); Console.WriteLine("Not necessary to download dataset."); datasetFile.FilePath = downloadHistory.FilePath; updatedDatasetFileToDownload.Add(datasetFile); } datasetFile.DownloadSuccess = true; } catch (Exception e) { Log.Error(e, "Error while downloading file " + datasetFile.Title); updatedDatasetFileToDownload.Add(datasetFile); fileLog.Message = "Error while downloading dataset: " + e.Message; downloadLog.Faild.Add(fileLog); Console.WriteLine("Error while downloading dataset: " + e.Message); datasetFile.DownloadSuccess = true; } Console.WriteLine("-------------"); } updatedDatasetToDownload.Add(localDataset); } Log.Information("Send download usage"); datasetService.SendDownloadUsage(downloadUsage); Log.Information("Write to config file"); datasetService.WriteToConfigFile(updatedDatasetToDownload); Log.Information("Write to download history file"); datasetService.WriteToDownloadHistoryFile(updatedDatasetToDownload); Log.Information("Write to download log file"); datasetService.WriteToDownloadLogFile(downloadLog); }
public DatasetController(DatasetService datasetService, DataMatrixLoader dataMatrixLoader) { _datasetService = datasetService; _dataMatrixLoader = dataMatrixLoader; }
/// <summary> /// Constructor: Initializes the DatasetService /// </summary> public DatasetsController() { _datasetService = new DatasetService(new DatasetRepository(DbContext)); }
/// <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) { }; } } }