Beispiel #1
0
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            try
            {
                await Task.Delay(TimeSpan.FromMinutes(2), stoppingToken);

                _logger.LogInformation($"{nameof(SampleWorker)} started!");

                while (!stoppingToken.IsCancellationRequested)
                {
                    try
                    {
                        await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);

                        if (_sessionService.IsActive())
                        {
                            var sessionId = _sessionService.GetSessionId();
                            if (sessionId.HasValue)
                            {
                                var sampleRequest = new CreateSampleForSessionRequest
                                {
                                    IsSaunaPowered    = await _gpioService.IsSaunaOn(),
                                    IsInfraredPowered = await _gpioService.IsInfraredOn(),
                                    Temperature       = await _gpioService.ReadTemperature(),
                                    TimeStamp         = DateTime.UtcNow
                                };

                                await _sampleClient.CreateSampleForSession(sessionId.Value, sampleRequest);

                                _logger.LogInformation("Sample for active session sent.");
                            }
                            else
                            {
                                _logger.LogInformation("No active session.");
                            }
                        }
                        else
                        {
                            _logger.LogInformation("No active session.");
                        }
                    }
                    catch (TaskCanceledException)
                    {
                        // This is most likely due to the Task.Delay being cancelled.
                    }
                }

                _logger.LogInformation($"{nameof(SampleWorker)} stopped!");
            }
            catch (Exception ex)
            {
                _logger.LogError($"{nameof(SampleWorker)} throws Exception: {ex.Message}!");
                await _logService.LogException(
                    "SessionWorker throws Exception!",
                    "SessionWorker throws Exception!", ex);
            }
        }
Beispiel #2
0
        public async Task <CreateSampleForSessionResponse> CreateSampleForSession(Guid sessionId, CreateSampleForSessionRequest request)
        {
            var session = await _sessionRepository.Single(x => x.Id == sessionId);

            if (session == null)
            {
                return(null);
            }

            var sampleToCreate = _createSampleForSessionRequestMapper.Map(request);

            sampleToCreate.Session = session;
            var createdSample = await _sampleRepository.Create(sampleToCreate);

            return(_createSampleForSessionResponseMapper.Map(createdSample));
        }
Beispiel #3
0
 public Task <CreateSampleForSessionResponse> CreateSampleForSession(Guid sessionId, CreateSampleForSessionRequest request)
 {
     return(_serviceClient.Post <CreateSampleForSessionResponse, CreateSampleForSessionRequest>(
                $"sauna/sessions/{sessionId}/samples", request));
 }
 public Task <IActionResult> CreateSampleForSession(Guid sessionId, [FromBody] CreateSampleForSessionRequest request)
 {
     return(Execute(x => x.CreateSampleForSession(sessionId, request)));
 }