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