public ConfigFile Load() { ConfigFile ConfigContent = new ConfigFile(); _loggerService.Debug("get configuration file..."); string filePath = Environment.GetEnvironmentVariable("RAWCMSCONFIG", EnvironmentVariableTarget.Process); if (string.IsNullOrEmpty(filePath)) { return(null); } _loggerService.Debug($"Config file: {filePath}"); try { // Open the text file using a stream reader. using (StreamReader sr = new StreamReader(filePath)) { string data = sr.ReadToEnd(); ConfigContent = new ConfigFile(data); _loggerService.Debug($"config loaded."); } } catch (Exception e) { _loggerService.Error("The file could not be read:", e); } return(ConfigContent); }
public List <string> GetRows(string documentPath, ICollection <string> stopWords = null, string[] skipWords = null) { try { _logger.Info("=== ENTERING PDF DOCUMENT EXTRACTOR ==="); _logger.Debug("Retrieving document stored at : " + documentPath); using (PdfReader reader = new PdfReader(documentPath)) { _logger.Info(documentPath + " successfully retrieved."); _logger.Debug("Preparing to read and process PDF content of " + documentPath); ITextExtractionStrategy strategy = new LocationTextExtractionStrategy(); List <string> parsedLines = new List <string>(); _logger.Info("PDF stream successfully read: " + documentPath); for (int i = 1; i <= reader.NumberOfPages; i++) { string page = PdfTextExtractor.GetTextFromPage(reader, i, strategy); if (skipWords != null && skipWords.Any(s => page.Contains(s))) { continue; } parsedLines.AddRange(page.Split('\n')); } if (_patternMatcher == null) { _patternMatcher = new NullPatternMatcher(); } if (stopWords != null) { parsedLines = parsedLines.TakeWhile(line => !stopWords.Any(line.Contains)) .Union(_patternMatcher.GetMatchedRows(parsedLines)) .ToList(); } _logger.Info(documentPath + " PDF stream successfully processed"); _logger.Info(parsedLines.Count + " rows processed and retrieved."); return(parsedLines); } } catch (ArgumentOutOfRangeException ex) { _logger.Error("ArgumentOutOfRangeException occurred: " + ex); } catch (Exception exception) { _logger.Error("Unknown exception occurred: " + exception); } return(new List <string>()); }
private async Task <bool> TryConnectAsync() { AppConfiguration appConfiguration = configurationService.GetConfiguration <AppConfiguration>(); IMqttClientOptions options = new MqttClientOptionsBuilder() .WithCleanSession() .WithClientId("主客户端 ID: 001") .WithCredentials("AD*米妮*斯托蕾塔", "^P@$$W0&D$") .WithTcpServer("localhost", appConfiguration.ListenPort) .Build(); client.UseConnectedHandler(e => { logger.Debug("Successfully connected to: {0}", e.AuthenticateResult.ResultCode); }) .UseDisconnectedHandler(async e => { logger.Warn("### DISCONNECTED FROM SERVER ###"); await Task.Delay(2000); try { if (CancellationTokenSource.IsCancellationRequested) { logger.Debug("### CancellationRequested ###"); return; } await client.ConnectAsync(options, CancellationTokenSource.Token); } catch { logger.Error("### RECONNECTING FAILED ###"); } }) .UseApplicationMessageReceivedHandler(e => { #if DEBUG string message = "\r\n### RECEIVED APPLICATION MESSAGE ###\r\n" + $"+ Topic = {e.ApplicationMessage.Topic}\r\n" + $"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}\r\n" + $"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}\r\n" + $"+ Retain = {e.ApplicationMessage.Retain}\r\n"; System.Diagnostics.Debug.WriteLine(message); #endif ExecuteMessage(e.ApplicationMessage.Topic, Encoding.UTF8.GetString(e.ApplicationMessage.Payload)); }); try { await client.ConnectAsync(options, CancellationTokenSource.Token); return(true); } catch (Exception ex) { logger.Error("Could not connect to server: {0}", ex.Message); return(false); } }
public void PreExposureDetected(ExposureConfiguration exposureConfiguration, long enVersion) { _loggerService.Debug("PreExposureDetected"); if (exposureConfiguration == null) { _loggerService.Error("PreExposureDetected is called but exposureConfiguration is null."); } }
public async Task <ActionResult <Entity.PaySlip> > CreatePaySlipAsync(Employee employee) { _loggerService.Info($"Begin Create Pay Slip Async."); _loggerService.Debug($"Begin Create Pay Slip Async. payload: {employee}"); var paySlip = await _paySlipService.CreatePaySlipAsync(employee); _loggerService.Info($"End Create Pay Slip Async."); _loggerService.Debug($"End Create Pay Slip Async. payload: {paySlip}"); return(paySlip); }
public void Debug(string format, params object[] param) { if ((_enabled & LoggerEventTypes.Debug) > 0) { _logger.Debug(format, param); } }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { switch (logLevel) { case LogLevel.Information: _quickloggerInstance.Info(_categoryName, $"{_categoryName}[{eventId.Id}] - {formatter(state, exception)}"); break; case LogLevel.Error: _quickloggerInstance.Error(_categoryName, $"{_categoryName}[{eventId.Id}] - {formatter(state, exception)}"); break; case LogLevel.Warning: _quickloggerInstance.Warning(_categoryName, $"{_categoryName}[{eventId.Id}] - {formatter(state, exception)}"); break; case LogLevel.Critical: _quickloggerInstance.Critical(_categoryName, $"{_categoryName}[{eventId.Id}] - {formatter(state, exception)}"); break; case LogLevel.Debug: _quickloggerInstance.Debug(_categoryName, $"{_categoryName}[{eventId.Id}] - {formatter(state, exception)}"); break; case LogLevel.Trace: _quickloggerInstance.Trace(_categoryName, $"{_categoryName}[{eventId.Id}] - {formatter(state, exception)}"); break; } }
public async Task <bool?> MoveImagesAsync(string serverIp, int serverPort, string serverAET, string localAET, string destAET, string studyInstanceUid, string seriesInstanceUid = null) { bool?success = null; DicomCMoveRequest request = string.IsNullOrEmpty(seriesInstanceUid) ? RequestFactory.CreateCMoveByStudyUID(destAET, studyInstanceUid) : RequestFactory.CreateCMoveBySeriesUID(destAET, studyInstanceUid, seriesInstanceUid); request.OnResponseReceived += (req, res) => { if (res.Status.State == DicomState.Pending) { logger.Info("Sending is in progress. please wait: " + res.Remaining.ToString()); } else if (res.Status.State == DicomState.Success) { logger.Info("Sending successfully finished."); success = true; } else if (res.Status.State == DicomState.Failure) { logger.Info("Error sending datasets: " + res.Status.Description); success = false; } logger.Debug("C-MOVE response status. " + res.Status.Description); }; DicomClient client = new DicomClient(serverIp, serverPort, false, localAET, serverAET); await client.AddRequestAsync(request); await client.SendAsync(); return(success); }
// POST /api/Register - Register User public async Task <bool> PostRegisterUserAsync() { #if TEST_BACKTASK loggerService.StartMethod(); loggerService.Debug(" skip /register "); loggerService.EndMethod(); return(true); #endif loggerService.StartMethod(); try { string url = AppSettings.Instance.ApiUrlBase + "/register"; var content = new StringContent(string.Empty, Encoding.UTF8, "application/json"); var result = await PostAsync(url, content); if (result != null) { loggerService.EndMethod(); return(true); } } catch (HttpRequestException ex) { loggerService.Exception("Failed to register user.", ex); } loggerService.EndMethod(); return(false); }
public void Debug(string message) { if (_service != null) { var detail = GetDebugDetail(message); _service.Debug(detail); } }
public static void Debug(string message) { if (_loggerService == null) { return; } _loggerService.Debug(message); }
public string GetToken(LoginOptions opts) { //string baseUrl = ClientConfig.GetValue<string>("BaseUrl"); string url = $"{opts.ServerUrl}/connect/token"; _loggerService.Debug($"Server url: {url}"); if (!_rawCmsService.Ping(url)) { _loggerService.Error("host not found."); return(string.Empty); } //create RestSharp client and POST request object RestClient client = new RestClient(url); RestRequest request = new RestRequest(Method.POST); //add GetToken() API method parameters request.Parameters.Clear(); request.AddParameter("grant_type", "password"); request.AddParameter("username", opts.Username); request.AddParameter("password", opts.Password); request.AddParameter("client_id", opts.ClientId); request.AddParameter("client_secret", opts.ClientSecret); request.AddParameter("scoope", "openid"); //make the API request and get the response IRestResponse response = client.Execute(request); TokenResponse res = Newtonsoft.Json.JsonConvert.DeserializeObject <TokenResponse>(response.Content); if (response.IsSuccessful) { _loggerService.Debug("Success response token"); return(res.access_token); } else { _loggerService.Warn("Unable to get valid token."); throw new ExceptionToken(res.error, res.error_description); } }
/// <summary> /// 参考 /// https://github.com/fo-dicom/fo-dicom-samples/blob/master/Desktop/Worklist%20SCU/Program.cs /// </summary> /// <param name="serverIp">Remote IP</param> /// <param name="serverPort">Remote Port</param> /// <param name="serverAET">Remote AET</param> /// <param name="localAET">Local AET</param> /// <param name="modality">Modality</param> /// <returns>Dataset</returns> public async Task <List <DicomDataset> > GetAllItemsFromWorklistAsync(string serverIp, int serverPort, string serverAET, string localAET, string modality = null) { List <DicomDataset> worklistItems = new List <DicomDataset>(); DicomCFindRequest worklistRequest = RequestFactory.CreateWorklistQuery(null, null, localAET, null, modality //, new DicomDateRange(DateTime.Today, DateTime.Today.AddHours(23).AddMinutes(59).AddSeconds(59)) // 时间限制:当天 00:00:00 ~ 23:59:59 ); worklistRequest.OnResponseReceived += (request, response) => { if (!response.HasDataset) { if (response.Status == DicomStatus.Success) { Logger.Debug("Worklist response END."); } else { Logger.Debug("Worklist response has [NO DATASET]."); } return; } if (response.Status != DicomStatus.Success && response.Status != DicomStatus.Pending && response.Status != DicomStatus.QueryRetrieveOptionalKeysNotSupported) { Logger.Error("Worklist response error - [{0}]", response.Status); return; } worklistItems.Add(response.Dataset); }; DicomClient client = new DicomClient(serverIp, serverPort, false, localAET, serverAET); await client.AddRequestAsync(worklistRequest); await client.SendAsync(); return(worklistItems); }
public async Task <(HttpStatusCode, IList <DiagnosisKeyEntry>)> GetDiagnosisKeysListAsync(string url, CancellationToken cancellationToken) { HttpResponseMessage response = await _httpClient.GetAsync(url, cancellationToken); if (response.IsSuccessStatusCode) { string content = await response.Content.ReadAsStringAsync(); _loggerService.Debug(content); return(response.StatusCode, JsonConvert.DeserializeObject <List <DiagnosisKeyEntry> >(content)); } else { _loggerService.Debug($"GetDiagnosisKeysListAsync {response.StatusCode}"); } return(response.StatusCode, new List <DiagnosisKeyEntry>()); }
private async Task <ExposureDataResponse?> UploadExposureDataAsync( ExposureRequest exposureRequest, string exposureDataCollectServerEndpoint ) { _loggerService.StartMethod(); _loggerService.Debug($"exposureDataCollectServerEndpoint: {exposureDataCollectServerEndpoint}"); try { var requestJson = exposureRequest.ToJsonString(); _loggerService.Info(requestJson); var httpContent = new StringContent(requestJson, Encoding.UTF8, "application/json"); Uri uri = new Uri(exposureDataCollectServerEndpoint); HttpResponseMessage response = await _httpClient.PutAsync(uri, httpContent); if (response.IsSuccessStatusCode) { var responseJson = await response.Content.ReadAsStringAsync(); _loggerService.Debug($"response {responseJson}"); return(JsonConvert.DeserializeObject <ExposureDataResponse>(responseJson)); } else { _loggerService.Info($"UploadExposureDataAsync {response.StatusCode}"); return(null); } } finally { _loggerService.EndMethod(); } }
public SimpleMqttService([Inject(Key = "filelogger")] ILoggerService loggerService) { logger = loggerService; users = new Dictionary <string, string>() { { "AD*米妮*斯托蕾塔", "^P@$$W0&D$" } }; server = new MqttFactory().CreateMqttServer(); server.UseApplicationMessageReceivedHandler(e => { string message = "\r\n### RECEIVED APPLICATION MESSAGE ###\r\n" + $"+ Topic = {e.ApplicationMessage.Topic}\r\n" + $"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}\r\n" + $"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}\r\n" + $"+ Retain = {e.ApplicationMessage.Retain}\r\n"; logger.Info(message); }).UseClientConnectedHandler(e => { logger.Debug($"[{e.ClientId}] Connected."); }) .UseClientDisconnectedHandler(e => { logger.Debug($"[{e.ClientId}] Disconnected."); }); }
public override void Schedule() { _loggerService.StartMethod(); var result = BGTaskScheduler.Shared.Register(BGTASK_IDENTIFIER, null, task => { _loggerService.Info("Background task has been started."); ScheduleBgTask(); var cancellationTokenSource = new CancellationTokenSource(); task.ExpirationHandler = cancellationTokenSource.Cancel; _ = Task.Run(async() => { try { await ExposureDetectionAsync(cancellationTokenSource); task.SetTaskCompleted(true); } catch (OperationCanceledException exception) { _loggerService.Exception($"Background task canceled.", exception); task.SetTaskCompleted(false); } catch (Exception exception) { _loggerService.Exception($"Exception", exception); task.SetTaskCompleted(false); } finally { cancellationTokenSource.Dispose(); } }, cancellationTokenSource.Token); }); if (result) { _loggerService.Debug("BGTaskScheduler.Shared.Register succeeded."); } else { _loggerService.Info("BGTaskScheduler.Shared.Register failed."); } ScheduleBgTask(); _loggerService.EndMethod(); }
public IRestResponse GetData(ListRequest req) { string url = $"{req.Url}/api/CRUD/{req.Collection}"; _loggerService.Debug($"Service url: {url}"); RestClient client = new RestClient(url); RestRequest request = new RestRequest(Method.GET) { //request headers RequestFormat = DataFormat.Json }; request.AddHeader("Content-Type", "application/json"); //add parameters and token to request request.Parameters.Clear(); if (!string.IsNullOrEmpty(req.RawQuery)) { request.AddParameter("rawQuery", req.RawQuery); } request.AddParameter("pageNumber", req.PageNumber); request.AddParameter("pageSize", req.PageSize); //request.AddParameter("Authorization", "Bearer " + req.Token, ParameterType.HttpHeader); // log request var fullUrl = client.BuildUri(request); _loggerService.Debug($"request URI: {fullUrl}"); //make the API request and get a response IRestResponse response = client.Execute(request); return(response); }
public TDbContext Get <TDbContext>(ILoggerService loggerService = null) where TDbContext : DbContext, IContext, new() { if (_dbContext == null || _dbContextType != typeof(TDbContext) || loggerService != null) { var db = new TDbContext(); if (loggerService != null) { db.Database.Log = (string message) => loggerService.Debug(message); } return(db); } return((TDbContext)_dbContext); }
public async Task <bool> StartAsync(int port) { if (server.IsStarted) { return(true); } Port = port; IMqttServerOptions options = new MqttServerOptionsBuilder() .WithApplicationMessageInterceptor(cv => { cv.AcceptPublish = true; }) .WithConnectionValidator(cv => { if (cv.ClientId.Length < 10) { cv.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid; return; } if (!users.ContainsKey(cv.Username) || users[cv.Username] != cv.Password) { cv.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword; return; } cv.ReasonCode = MqttConnectReasonCode.Success; }) .WithEncryptionSslProtocol(System.Security.Authentication.SslProtocols.Tls12) .WithDefaultEndpointPort(port) .WithSubscriptionInterceptor(cv => { cv.AcceptSubscription = true; }) .Build(); try { await server.StartAsync(options); logger.Debug("Mqtt server is running at: {0}", port); return(true); } catch (Exception ex) { logger.Error(ex); return(false); } }
protected override void OnBefore(IInvocation invocation) { var logParameters = invocation.Method.GetParameters() .Select((t, i) => new LogParameter { Name = t.Name, Type = t.ParameterType.Name, Value = invocation.Arguments[i] }).ToList(); var logDetail = new LogDetail { FullName = invocation.Method.DeclaringType == null ? null : invocation.Method.DeclaringType.Name, MethodName = invocation.Method.Name, LogParameters = logParameters }; _loggerService.Debug(logDetail); }
public void Run() { Commands.Add(new Get()); Commands.Add(new Send()); Commands.Add(new GetChat()); Commands.Add(new GetInfo()); Commands.Add(new LoginCommand()); Commands.Add(new RegisterCommand()); Commands.Add(new ErrorCommand()); IsRun = true; var config = _container.Resolve <ConfigService>().GetConfig(); if (config is null) { _logger.Warning("Остановка сервера...."); IsRun = false; return; } _logger.Warning($"Запуск сервера по адресу {config.Connect.Ip}:{config.Connect.Port}..."); _logger.Debug("Привязка ip и port..."); try { var ipAddress = IPAddress.Parse(config.Connect.Ip); var listener = new TcpListener(ipAddress, config.Connect.Port); var connectService = _container.Resolve <ConnectService>(); Task.Run(() => { connectService.StartCheckConnect(listener); }); Task.Run((() => { _checker.StartService(); })); } catch (Exception e) { IsRun = false; _logger.Error("Произошла ошибка при привязке ip и port", e); return; } }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { if (!IsEnabled(logLevel)) { return; } string message = formatter != null?formatter(state, exception) : state.ToString(); if (string.IsNullOrWhiteSpace(message) && exception != null) { message = exception.Message; } switch (logLevel) { case LogLevel.Error: _quickloggerInstance.Error(_categoryName, $"{_categoryName}[{eventId.Id}] - {message}"); break; case LogLevel.Warning: _quickloggerInstance.Warning(_categoryName, $"{_categoryName}[{eventId.Id}] - {message}"); break; case LogLevel.Critical: _quickloggerInstance.Critical(_categoryName, $"{_categoryName}[{eventId.Id}] - {message}"); break; case LogLevel.Debug: _quickloggerInstance.Debug(_categoryName, $"{_categoryName}[{eventId.Id}] - {message}"); break; case LogLevel.Trace: _quickloggerInstance.Trace(_categoryName, $"{_categoryName}[{eventId.Id}] - {message}"); break; default: _quickloggerInstance.Info(_categoryName, $"{_categoryName}[{eventId.Id}] - {message}"); break; } }
public IActionResult Authenticate([FromBody] AuthenticateRequest request) { if (!ModelState.IsValid) { return(BadRequest()); } var user = _userService.Authenticate(request); if (user == null) { return(Unauthorized()); } var role = _userService.GetUserRole(user.UserId); if (role != null) { user.Role = role.ToList(); } var claims = new[] { new Claim(ClaimTypes.Sid, user.UserId.ToString()), new Claim(ClaimTypes.Name, user.OriginalUserName), new Claim(ClaimTypes.UserData, JsonHelper.SerializeObject <AuthenticateResponse>(user)) }; foreach (var _role in user.Role) { claims.Append(new Claim(ClaimTypes.Role, _role.RoleName)); } var jwtResult = _jwtAuthManagerService.GenerateTokens(user.UserName, claims, DateTime.Now); _loggerService.Debug($"User [{user.UserName}] logged in the system."); user.AccessToken = jwtResult.AccessToken; user.RefreshToken = jwtResult.RefreshToken; return(Ok(user)); }
private async Task SendExposureDataAsync( string idempotencyKey, ExposureData exposureData ) { _loggerService.StartMethod(); SendEventLogState sendEventLogState = _userDataRepository.GetSendEventLogState(); bool isEnabled = sendEventLogState == SendEventLogState.Enable; if (!isEnabled) { _loggerService.Debug($"Send event-log function is not enabled."); _loggerService.EndMethod(); return; } await _serverConfigurationRepository.LoadAsync(); string exposureDataCollectServerEndpoint = _serverConfigurationRepository.EventLogApiEndpoint; _loggerService.Debug($"exposureDataCollectServerEndpoint: {exposureDataCollectServerEndpoint}"); try { var contentJson = exposureData.ToJsonString(); var eventLog = new V1EventLogRequest.EventLog() { HasConsent = isEnabled, Epoch = _dateTimeUtility.UtcNow.ToUnixEpoch(), Type = "ExposureData", Subtype = "Debug", Content = contentJson, }; var eventLogs = new[] { eventLog }; var request = new V1EventLogRequest() { IdempotencyKey = idempotencyKey, Platform = _essentialsService.Platform, AppPackageName = _essentialsService.AppPackageName, EventLogs = eventLogs, }; request.DeviceVerificationPayload = await _deviceVerifier.VerifyAsync(request); var requestJson = request.ToJsonString(); var httpContent = new StringContent(requestJson, Encoding.UTF8, "application/json"); Uri uri = new Uri(exposureDataCollectServerEndpoint); HttpResponseMessage response = await _httpClient.PutAsync(uri, httpContent); if (response.IsSuccessStatusCode) { var responseJson = await response.Content.ReadAsStringAsync(); _loggerService.Debug($"{responseJson}"); } else { _loggerService.Info($"UploadExposureDataAsync {response.StatusCode}"); } } finally { _loggerService.EndMethod(); } }
public List <string> GetRows(string documentPath, ICollection <string> stopWords = null, string[] skipWords = null) { var memoryStream = new MemoryStream(); try { _logger.Info("=== ENTERING WORD DOCUMENT EXTRACTOR ==="); _logger.Debug("Retrieving document stored at : " + documentPath); Document document = new Document(documentPath); _logger.Info(documentPath + " successfully retrieved."); _logger.Debug("Converting and saving document " + documentPath + " as PDF in memory."); ThrowIfTimedOut( () => document.SaveToFile(memoryStream, FileFormat.PDF), TimeSpan.FromSeconds(10) ); _logger.Info(documentPath + " successfully converted to PDF."); memoryStream.Position = 0; using (PdfReader reader = new PdfReader(memoryStream)) { _logger.Debug("Preparing to read and process PDF content of " + documentPath); ITextExtractionStrategy strategy = new LocationTextExtractionStrategy(); List <string> parsedLines = new List <string>(); _logger.Info("PDF stream successfully read: " + documentPath); for (int i = 1; i <= reader.NumberOfPages; i++) { string page = PdfTextExtractor.GetTextFromPage(reader, i, strategy); if (skipWords != null && skipWords.Any(s => page.Contains(s))) { continue; } parsedLines.AddRange(page.Split('\n')); } if (_patternMatcher == null) { _patternMatcher = new NullPatternMatcher(); } if (stopWords != null) { parsedLines = parsedLines.TakeWhile(line => !stopWords.Any(line.Contains)) .Union(_patternMatcher.GetMatchedRows(parsedLines)) .ToList(); } _logger.Info(documentPath + " PDF stream successfully processed"); _logger.Info(parsedLines.Count + " rows processed and retrieved."); return(parsedLines); } } catch (ArgumentOutOfRangeException ex) { _logger.Error("ArgumentOutOfRangeException occurred: " + ex); } catch (Exception exception) { _logger.Error("Unknown exception occurred: " + exception); } finally { memoryStream.Dispose(); } return(new List <string>()); }
private int RunInsertOptionsCode(InsertOptions opts) { bool Verbose = opts.Verbose; bool Recursive = opts.Recursive; bool DryRun = opts.DryRun; bool Pretty = opts.Pretty; string collection = opts.Collection; string filePath = opts.FilePath; string folderPath = opts.FolderPath; // setting log/console Output _loggerService.SetVerbose(Verbose); _loggerService.SetPretty(Pretty); // check token befare action.. ConfigFile config = _configService.Load(); if (config == null) { _loggerService.Warn("No configuratin file found. Please login before continue."); _loggerService.Warn("Program aborted."); return(0); } string token = config.Token; if (string.IsNullOrEmpty(token)) { _loggerService.Warn("No token found. Please login before continue."); _loggerService.Warn("Program aborted."); return(0); } ; _loggerService.Debug($"Working into collection: {collection}"); Dictionary <string, List <string> > listFile = new Dictionary <string, List <string> >(); // pass a file to options if (!string.IsNullOrEmpty(filePath)) { // check if file exists if (!File.Exists(filePath)) { _loggerService.Warn($"File not found: {filePath}"); return(0); } // check if file is valid json int check = _rawCmsService.CheckJSON(filePath); if (check != 0) { _loggerService.Warn("Json is not well-formatted. Skip file."); return(0); } List <string> filelist = new List <string> { filePath }; listFile.Add(collection, filelist); } else if (!string.IsNullOrEmpty(folderPath)) { string cwd = Directory.GetCurrentDirectory(); _loggerService.Info($"Current working directory: {cwd}"); // get all file from folder if (!Directory.Exists(folderPath)) { _loggerService.Warn($"File not found: {filePath}"); return(0); } // This path is a directory // get first level path, // folder => collection DirectoryInfo dInfo = new DirectoryInfo(folderPath); DirectoryInfo[] subdirs = dInfo.GetDirectories(); foreach (DirectoryInfo subDir in subdirs) { _rawCmsService.ProcessDirectory(Recursive, listFile, subDir.FullName, subDir.Name); } } else { _loggerService.Warn("At least one of the two options -f (file) or -d (folder) is mandatory."); return(0); } _rawCmsService.ElaborateQueue(listFile, config, Pretty); _loggerService.Info($"Processing file complete."); return(0); }
private async Task <ExposureConfiguration> GetExposureConfigurationInternalAsync() { _loggerService.StartMethod(); ExposureConfiguration currentExposureConfiguration = null; if (File.Exists(_currentExposureConfigurationPath)) { _loggerService.Debug("ExposureConfiguration file is found."); try { string exposureConfigurationAsJson = await LoadAsync(_currentExposureConfigurationPath); currentExposureConfiguration = JsonConvert.DeserializeObject <ExposureConfiguration>(exposureConfigurationAsJson); _loggerService.Info("Cached:" + exposureConfigurationAsJson); if (!IsDownloadedExposureConfigurationOutdated(AppConstants.ExposureConfigurationFileDownloadCacheRetentionDays)) { _loggerService.EndMethod(); return(currentExposureConfiguration); } else { _loggerService.Info($"ExposureConfiguration is found but the file is outdated."); } } catch (IOException exception) { _loggerService.Exception("IOException. ExposureConfiguration file has been deleted.", exception); RemoveExposureConfigurationInternal(); } catch (JsonException exception) { _loggerService.Exception("JsonException. ExposureConfiguration file has been deleted.", exception); RemoveExposureConfigurationInternal(); } } // Cache not exist (first time. probably...) if (currentExposureConfiguration is null) { currentExposureConfiguration = CreateDefaultConfiguration(); SetExposureConfigurationDownloadedDateTime(_dateTimeUtility.UtcNow); SetIsDiagnosisKeysDataMappingConfigurationUpdated(true); } await _serverConfigurationRepository.LoadAsync(); string url = _serverConfigurationRepository.ExposureConfigurationUrl; ExposureConfiguration newExposureConfiguration = null; var response = await _httpClient.GetAsync(url); if (response.IsSuccessStatusCode) { string exposureConfigurationAsJson = await response.Content.ReadAsStringAsync(); try { newExposureConfiguration = JsonConvert.DeserializeObject <ExposureConfiguration>(exposureConfigurationAsJson); _loggerService.Info("Downloaded:" + exposureConfigurationAsJson); SetExposureConfigurationDownloadedDateTime(_dateTimeUtility.UtcNow); } catch (JsonException exception) { _loggerService.Exception("JsonException.", exception); } } else { _loggerService.Warning($"Download ExposureConfiguration failed from {url}"); } if (newExposureConfiguration is null) { _loggerService.EndMethod(); return(currentExposureConfiguration); } if (IsUpdatedDiagnosisKeysDataMapping(currentExposureConfiguration, newExposureConfiguration)) { if (IsExposureConfigurationOutdated(AppConstants.MinimumDiagnosisKeysDataMappingApplyIntervalDays)) { currentExposureConfiguration = newExposureConfiguration; SetIsDiagnosisKeysDataMappingConfigurationUpdated(true); } else { _loggerService.Info($"DiagnosisKeysDataMappingConfig has been changed but not updated, because current configuration is updated in {AppConstants.MinimumDiagnosisKeysDataMappingApplyIntervalDays} days."); } } else { currentExposureConfiguration = newExposureConfiguration; } string tmpFilePath = Path.Combine(_configDir, Guid.NewGuid().ToString()); try { await SaveAsync( JsonConvert.SerializeObject(currentExposureConfiguration, Formatting.Indented), tmpFilePath ); Swap(tmpFilePath, _currentExposureConfigurationPath); return(currentExposureConfiguration); } finally { File.Delete(tmpFilePath); _loggerService.EndMethod(); } }
private async Task InternalExposureDetectionAsync(CancellationTokenSource cancellationTokenSource = null) { bool isEnabled = await _exposureNotificationApiService.IsEnabledAsync(); if (!isEnabled) { _loggerService.Info($"EN API is not enabled."); return; } IEnumerable <int> statuseCodes = await _exposureNotificationApiService.GetStatusCodesAsync(); bool isActivated = statuseCodes.Contains(ExposureNotificationStatus.Code_Android.ACTIVATED) | statuseCodes.Contains(ExposureNotificationStatus.Code_iOS.Active); if (!isActivated) { _loggerService.Info($"EN API is not ACTIVATED."); return; } var cancellationToken = cancellationTokenSource?.Token ?? default(CancellationToken); await _serverConfigurationRepository.LoadAsync(); bool canConfirmExposure = true; bool isMaxPerDayExposureDetectionAPILimitReached = false; foreach (var region in _serverConfigurationRepository.Regions) { _loggerService.Info($"Region: {region}"); var diagnosisKeyListProvideServerUrl = _serverConfigurationRepository.GetDiagnosisKeyListProvideServerUrl(region); _loggerService.Info($"diagnosisKeyListProvideServerUrl: {diagnosisKeyListProvideServerUrl}"); List <string> downloadedFileNameList = new List <string>(); try { var tmpDir = PrepareDir(region); var(httpStatus, diagnosisKeyEntryList) = await _diagnosisKeyRepository.GetDiagnosisKeysListAsync( diagnosisKeyListProvideServerUrl, cancellationToken ); if (httpStatus != HttpStatusCode.OK) { _loggerService.Info($"URL: {diagnosisKeyListProvideServerUrl}, Response StatusCode: {httpStatus}"); canConfirmExposure = false; continue; } var lastProcessTimestamp = await _userDataRepository.GetLastProcessDiagnosisKeyTimestampAsync(region); _loggerService.Info($"Region: {region}, lastProcessTimestamp: {lastProcessTimestamp}"); var targetDiagnosisKeyEntryList = FilterDiagnosisKeysAfterLastProcessTimestamp(diagnosisKeyEntryList, lastProcessTimestamp); if (targetDiagnosisKeyEntryList.Count() == 0) { _loggerService.Info($"No new diagnosis-key found on {diagnosisKeyListProvideServerUrl}"); continue; } _loggerService.Info($"{targetDiagnosisKeyEntryList.Count()} new keys found."); foreach (var diagnosisKeyEntry in targetDiagnosisKeyEntryList) { string filePath = await _diagnosisKeyRepository.DownloadDiagnosisKeysAsync(diagnosisKeyEntry, tmpDir, cancellationToken); _loggerService.Info($"URL {diagnosisKeyEntry.Url} have been downloaded."); downloadedFileNameList.Add(filePath); } var downloadedFileNames = string.Join("\n", downloadedFileNameList); _loggerService.Debug(downloadedFileNames); await _exposureNotificationApiService.ProvideDiagnosisKeysAsync( downloadedFileNameList, cancellationTokenSource ); // Save LastProcessDiagnosisKeyTimestamp after ProvideDiagnosisKeysAsync was succeeded. var latestProcessTimestamp = targetDiagnosisKeyEntryList .Select(diagnosisKeyEntry => diagnosisKeyEntry.Created) .Max(); await _userDataRepository.SetLastProcessDiagnosisKeyTimestampAsync(region, latestProcessTimestamp); _userDataRepository.SetLastConfirmedDate(_dateTimeUtility.UtcNow); _userDataRepository.SetCanConfirmExposure(true); _userDataRepository.SetIsMaxPerDayExposureDetectionAPILimitReached(isMaxPerDayExposureDetectionAPILimitReached); } catch (ENException exception) { canConfirmExposure = false; isMaxPerDayExposureDetectionAPILimitReached = CheckMaxPerDayExposureDetectionAPILimitReached(exception); _loggerService.Exception($"ENExcepiton occurred, Code:{exception.Code}, Message:{exception.Message}", exception); throw; } catch (Exception exception) { canConfirmExposure = false; _loggerService.Exception($"Exception occurred: {region}", exception); throw; } finally { RemoveFiles(downloadedFileNameList); _userDataRepository.SetCanConfirmExposure(canConfirmExposure); _userDataRepository.SetIsMaxPerDayExposureDetectionAPILimitReached(isMaxPerDayExposureDetectionAPILimitReached); } } }
protected virtual void OnElement(Timestamped <IElement> element) { _logger.Debug("{0}: OnElement ({1}): {2}", Id, element.Timestamp, element.Value); }