async Task MessageConsumer_TestCompletedOnSourceAsync(TestCompletedOnSourceMessage arg) { using var scope = ScopeFactory.CreateScope(); using var db = scope.ServiceProvider.GetRequiredService <RunnerContext>(); var runInfo = await db.TestRuns .IncludeGroup(API.Models.EntityGroups.ALL, db) .FirstAsync(r => r.TestId == arg.TestId); var result = runInfo.Results .FirstOrDefault(r => r.Id == arg.ResultId); if (result != null) // because it could have been deleted { if (result.ResultBase.Result != RunResult.Aborted) { arg.Result.TestId = arg.TestId; arg.Result.TestName = runInfo.TestName; arg.Result.StartedByUser = result.ResultBase.StartedByUser; result.ResultBase = arg.Result; await db.SaveChangesAsync(); MessageProducer.FireTestCompleted(new TestCompletedMessage() { TestId = runInfo.TestName, Result = arg.Result }); } } }
protected override void DoStartAsync(object stoppingToken) { Logger.LogInformation($"{openWeatherMapOptions.Cities.Length} connected sensor(s)"); client.BaseAddress = new Uri("http://api.openweathermap.org/data/2.5/"); for (int i = 0; i < openWeatherMapOptions.Cities.Length; i++) { string rom = openWeatherMapOptions.Cities[i].ToString(); using (var scope = ScopeFactory.CreateScope()) { IUnitOfWork <Sensor> sensorsUnitOfWork = scope.ServiceProvider.GetRequiredService <IUnitOfWork <Sensor> >(); var dbSensor = sensorsUnitOfWork.GetRepository().Query().FirstOrDefault(sn => sn.ROM == rom); if (dbSensor == null) { Sensors.Add(new SensorDTO() { SensorID = -i - 1, ROM = rom, DeviceName = $"OpenWeather sensor for city id {rom}" }); } else { Sensors.Add(new SensorDTO() { SensorID = dbSensor.snID, ROM = rom, DeviceName = $"OpenWeather sensor for city id {rom}" }); } Logger.LogInformation($"Added to list sensor with ROM (CityID): {rom}"); } } }
private void HistoryDeleteButton_Click(object sender, EventArgs e) { if (!(historyDataGridView.CurrentRow?.DataBoundItem is Job job)) { return; } using (var scope = ScopeFactory.CreateScope()) { var db = scope.ServiceProvider.GetService <BibleContext>(); if (db.Jobs.Any(i => i.Id == job.Id)) { db.Jobs.Attach(job); db.Jobs.Remove(job); db.SaveChanges(); } } // 취소 불가능하면 바로 제거 if (FindHistoryDataGridViewRow(job).Tag == null) { jobHistory.RemoveAt(FindHistoryDataGridViewRow(job).Index); } // 취소 가능하면 취소로 제거 else { Builder.Cancel(job); } }
/// <summary> /// Set a custom state on the session which can be later retrieved using <see cref="GetSessionStateAsync"/> /// </summary> /// /// <param name="sessionState">A <see cref="BinaryData"/> of session state</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// /// <remarks>This state is stored on Service Bus forever unless you set an empty state on it.</remarks> /// /// <returns>A task to be resolved on when the operation has completed.</returns> public virtual async Task SetSessionStateAsync( BinaryData sessionState, CancellationToken cancellationToken = default) { Argument.AssertNotDisposed(IsClosed, nameof(ServiceBusSessionReceiver)); cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>(); Logger.SetSessionStateStart(Identifier, SessionId); using DiagnosticScope scope = ScopeFactory.CreateScope( DiagnosticProperty.SetSessionStateActivityName, sessionId: SessionId); scope.Start(); try { await InnerReceiver.SetStateAsync(sessionState, cancellationToken).ConfigureAwait(false); } catch (Exception exception) { Logger.SetSessionStateException(Identifier, exception.ToString()); scope.Failed(exception); throw; } Logger.SetSessionStateComplete(Identifier); }
public static async Task <TResponse> SendAsync <TResponse>(IRequest <TResponse> request) { var scope = ScopeFactory.CreateScope(); var mediator = scope.ServiceProvider.GetService <IMediator>(); return(await mediator.Send(request)); }
async Task daemon() { await ThreadingUtils.ContinueAtDedicatedThread(); while (true) { try { using var scope = ScopeFactory.CreateScope(); using var db = scope.ServiceProvider.GetRequiredService <TestsContext>(); var threshold = DateTime.UtcNow.AddDays(-3); var legacy = await db.Cases .Where(c => c.State == TestCaseState.RecordedButNotSaved && c.CreationDate < threshold) .ToArrayAsync(); foreach (var e in legacy) { e.IsDeleted = true; } await db.SaveChangesAsync(); Logger.LogInformation($"{legacy.Length} cases have been deleted"); } catch (Exception ex) { Logger.LogError(ex, "Could not cleanup"); } await Task.Delay(3600 * 1000); } }
/// <summary> /// Renews the lock on the message. The lock will be renewed based on the setting specified on the queue. /// </summary> /// /// <remarks> /// When a message is received in <see cref="ReceiveMode.PeekLock"/> mode, the message is locked on the server for this /// receiver instance for a duration as specified during the Queue/Subscription creation (LockDuration). /// If processing of the message requires longer than this duration, the lock needs to be renewed. /// For each renewal, it resets the time the message is locked by the LockDuration set on the Entity. /// </remarks> /// /// <param name="lockToken">The lockToken of the <see cref="ServiceBusReceivedMessage"/> to renew the lock for.</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> public virtual async Task <DateTimeOffset> RenewMessageLockAsync( string lockToken, CancellationToken cancellationToken = default) { ThrowIfLockTokenIsEmpty(lockToken); Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusReceiver)); ThrowIfNotPeekLockMode(); ThrowIfSessionReceiver(); cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>(); Logger.RenewMessageLockStart(Identifier, 1, lockToken); using DiagnosticScope scope = ScopeFactory.CreateScope( DiagnosticProperty.RenewMessageLockActivityName, lockToken: lockToken); scope.Start(); DateTimeOffset lockedUntil; try { lockedUntil = await InnerReceiver.RenewMessageLockAsync( lockToken, cancellationToken).ConfigureAwait(false); } catch (Exception exception) { Logger.RenewMessageLockException(Identifier, exception.ToString()); scope.Failed(exception); throw; } Logger.RenewMessageLockComplete(Identifier); scope.AddAttribute(DiagnosticProperty.LockedUntilAttribute, lockedUntil); return(lockedUntil); }
/// <summary> /// Receives a <see cref="IList{ServiceBusReceivedMessage}"/> of deferred messages identified by <paramref name="sequenceNumbers"/>. /// </summary> /// /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// <param name="sequenceNumbers">An <see cref="IEnumerable{T}"/> containing the sequence numbers to receive.</param> /// /// <returns>Messages identified by sequence number are returned. Returns null if no messages are found. /// Throws if the messages have not been deferred.</returns> /// <seealso cref="DeferMessageAsync(ServiceBusReceivedMessage, IDictionary{string, object}, CancellationToken)"/> /// <seealso cref="DeferMessageAsync(string, IDictionary{string, object}, CancellationToken)"/> public virtual async Task <IList <ServiceBusReceivedMessage> > ReceiveDeferredMessagesAsync( IEnumerable <long> sequenceNumbers, CancellationToken cancellationToken = default) { Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusReceiver)); Argument.AssertNotNullOrEmpty(sequenceNumbers, nameof(sequenceNumbers)); cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>(); var sequenceNumbersList = sequenceNumbers.ToList(); Logger.ReceiveDeferredMessageStart(Identifier, sequenceNumbersList); using DiagnosticScope scope = ScopeFactory.CreateScope(DiagnosticProperty.ReceiveDeferredActivityName); scope.AddAttribute( DiagnosticProperty.SequenceNumbersAttribute, string.Join(",", sequenceNumbers)); scope.Start(); IList <ServiceBusReceivedMessage> deferredMessages = null; try { deferredMessages = await InnerReceiver.ReceiveDeferredMessagesAsync( sequenceNumbersList, cancellationToken).ConfigureAwait(false); } catch (Exception exception) { Logger.ReceiveDeferredMessageException(Identifier, exception.ToString()); scope.Failed(exception); throw; } Logger.ReceiveDeferredMessageComplete(Identifier, deferredMessages.Count); scope.SetMessageData(deferredMessages); return(deferredMessages); }
public async void ImportPaymentsVippsFiles(IFileListEntry[] files) { ErrorMessage = ""; using (var scope = ScopeFactory.CreateScope()) { var db = scope.ServiceProvider.GetService <TandemBookingContext>(); foreach (var file in files) { try { await ImportPaymentsVippsFile(db, file); await db.SaveChangesAsync(); } catch (Exception ex) { ErrorMessage += " " + ex.Message; } } } await Load(); }
public async Task <TResult> ExecureAsync <TResult>( Expression <Func <PosState, Task <TResult> > > serviceMethod, Func <TResult, Task> efterbehandling = null ) { try { var serviceMethodCall = serviceMethod.Compile(); using var serviceScope = ScopeFactory.CreateScope(); //var service = posState; var service = PosState; // serviceScope.ServiceProvider.GetService<PosState>(); if (!service.IsInitilized) { service.Init(Id); } var result = await serviceMethodCall(service); if (efterbehandling != null) { await efterbehandling(result); } return(result); } catch (Exception ex) { Console.WriteLine(ex.Message); throw; } }
protected override void DoStartAsync(object stoppingToken) { Logger.LogInformation($"{sensorsCount} connected sensor(s)"); for (int i = 0; i < sensorsCount; i++) { int rndROM = 111111111 + i; using (var scope = ScopeFactory.CreateScope()) { IUnitOfWork <Sensor> sensorsUnitOfWork = scope.ServiceProvider.GetRequiredService <IUnitOfWork <Sensor> >(); var dbSensor = sensorsUnitOfWork.GetRepository().Query().FirstOrDefault(sn => sn.ROM == rndROM.ToString()); if (dbSensor == null) { Sensors.Add(new SensorDTO() { SensorID = rndROM, Name = $"Dummy sensor {i}", ROM = rndROM.ToString(), DeviceName = $"Sensor {rndROM}" }); } else { Sensors.Add(new SensorDTO() { SensorID = dbSensor.snID, Name = dbSensor.Name, ROM = dbSensor.ROM, DeviceName = $"Sensor {rndROM}" }); } Logger.LogInformation($"Added to list sensor with ROM: {rndROM}"); } } }
internal async Task ProcessMessage(string label, string body, Func <Task> markCompleted, Func <string, Task> abort) { bool MessageExpired(TimeEvent m) { var age = DateTime.Now.Subtract(DateTime.Parse(m.Time)); return(age > TimeSpan.FromMinutes(3.0)); } var message = (TimeEvent)JsonConvert.DeserializeObject(body, typeof(TimeEvent)); if (MessageExpired(message)) { Log.Warning($"Ignoring expired message. Time: {message.Time}"); await markCompleted(); return; } using (var scope = ScopeFactory.CreateScope()) { var job = (ITimerJob)scope.ServiceProvider.GetRequiredService(JobType); var r = await job.Handler(message); if (HandlerResult.IsAbort(r)) { await abort(r.Message); } if (HandlerResult.IsSuccess(r)) { await markCompleted(); } } }
public async Task <string> RunAsUserAsync(string userName, string password) { using var scope = ScopeFactory.CreateScope(); var userManager = scope.ServiceProvider.GetService <UserManager <ApplicationUser> >(); var existingUser = await userManager.FindByNameAsync(userName); if (existingUser != null) { return(existingUser.Id); } var user = new ApplicationUser { UserName = userName, Email = userName }; var result = await userManager.CreateAsync(user, password); if (result.Succeeded) { CurrentUserId = user.Id; return(CurrentUserId); } var errors = string.Join(Environment.NewLine, result.ToApplicationResult().Errors); throw new Exception($"Unable to create {userName}.{Environment.NewLine}{errors}"); }
/// <summary> Indicates that the receiver wants to defer the processing for the message.</summary> /// /// <param name="lockToken">The lockToken of the <see cref="ServiceBusReceivedMessage"/> to defer.</param> /// <param name="propertiesToModify">The properties of the message to modify while deferring the message.</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// /// <remarks> /// A lock token can be found in <see cref="ServiceBusReceivedMessage.LockToken"/>, /// only when <see cref="ReceiveMode"/> is set to <see cref="ReceiveMode.PeekLock"/>. /// In order to receive this message again in the future, you will need to save the /// <see cref="ServiceBusReceivedMessage.SequenceNumber"/> /// and receive it using <see cref="ReceiveDeferredMessageAsync(long, CancellationToken)"/>. /// Deferring messages does not impact message's expiration, meaning that deferred messages can still expire. /// This operation can only be performed on messages that were received by this receiver. /// </remarks> /// /// <returns>A task to be resolved on when the operation has completed.</returns> public virtual async Task DeferMessageAsync( string lockToken, IDictionary <string, object> propertiesToModify = null, CancellationToken cancellationToken = default) { ThrowIfLockTokenIsEmpty(lockToken); Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusReceiver)); ThrowIfNotPeekLockMode(); cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>(); Logger.DeferMessageStart(Identifier, 1, lockToken); using DiagnosticScope scope = ScopeFactory.CreateScope( DiagnosticProperty.DeferActivityName, lockToken: lockToken); scope.Start(); try { await InnerReceiver.DeferAsync( lockToken, propertiesToModify, cancellationToken).ConfigureAwait(false); } catch (Exception exception) { Logger.DeferMessageException(Identifier, exception.ToString()); scope.Failed(exception); throw; } Logger.DeferMessageComplete(Identifier); }
internal async Task ProcessMessage(string label, string body, Func <Task> markCompleted, Func <string, Task> abort) { var typeFromLabel = Registry.GetMessageTypeByName(label); if (typeFromLabel != default) { var message = JsonConvert.DeserializeObject(body, typeFromLabel); using (var scope = ScopeFactory.CreateScope()) { var tasks = Registry .GetHandlers(message.GetType(), scope) .ToList() // avoid deferred execution, we want all handlers to execute .Select(h => CallHandler(h, message, abort)) .ToArray(); var results = await Task.WhenAll(tasks); if (results.All(r => r)) { await markCompleted(); } } } else { Log.Debug("No handler registered for the given {Label}. {@Body}", label, body); await markCompleted(); } }
async Task daemon() { await ThreadingUtils.ContinueAtDedicatedThread(); while (true) { try { using var scope = ScopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService <RunnerContext>(); var toUpdate = await db.RunResults .AsNoTracking() .IncludeGroup(API.Models.EntityGroups.ALL, db) .Where(r => !r.ResultBase.State.IsFinal && r.ResultBase.State.NextStateUpdate != null && r.ResultBase.State.NextStateUpdate.Value < DateTime.UtcNow) .ToArrayAsync(); foreach (var r in toUpdate) { Producer.FireUpdateTestResultState(new UpdateTestResultStateMessage(r.ResultBase.TestId, r.Id, r.ResultBase.SourceId, r.ResultBase.State)); } } catch (Exception ex) { Debugger.Break(); } await Task.Delay(10 * 1000); } }
private async Task Load() { using (var scope = ScopeFactory.CreateScope()) { var db = scope.ServiceProvider.GetService <TandemBookingContext>(); UnreconciledBookings = await db.Bookings .Where(b => b.Completed && !b.Canceled && b.PassengerFee > 0 && b.ReconciledDate == null) .Include(b => b.AssignedPilot) .Include(b => b.PaymentAccount) .Include(b => b.BookingPayments) .OrderBy(b => b.BookingDate) .AsNoTracking() .ToListAsync(); UnreconciledPayments = await db.Payments .Where(p => p.UnreconciledAmount > 0) .Include(p => p.PaymentAccount) .OrderBy(p => p.PaymentDate) .AsNoTracking() .ToListAsync(); PaymentAccounts = await db.PaymentAccounts .Where(p => p.Active) .OrderBy(p => p.Name) .ToListAsync(); } }
async Task Consumer_TestAcquiredAsync(TestAcquiringResultMessage arg) { using var scope = ScopeFactory.CreateScope(); using var db = scope.ServiceProvider.GetRequiredService <TestsContext>(); var test = new TestCase() { TestName = arg.DefaultTestName, TestDescription = arg.DefaultTestDescription, CreationDate = DateTime.UtcNow, Data = new TestCaseData() { Data = arg.TestData, Type = arg.TestType, Parameters = arg.Parameters, KeyParameters = arg.KeyParameters.Select(kvp => new KeyParameter(kvp.Key, kvp.Value)).ToList() }, State = TestCaseState.RecordedButNotSaved, }; await db.Cases.AddAsync(test); await db.SaveChangesAsync(); MessageProducer.FireTestRecorded(new TestRecordedMessage(test.TestId, test.TestName, test.TestDescription)); }
private async Task <bool> HandleCurrentPassAsync(long currentPassHeight, CancellationToken cancellationToken) { bool processedAny = false; while (true) { long height = 0; using (var scope = ScopeFactory.CreateScope()) { var db = scope.ServiceProvider.GetRequiredService <PoolContext>(); using (var transaction = await db.Database.BeginTransactionAsync(cancellationToken)) { var nextBlock = await db.BlockStates.Where(i => !i.SharesAveraged && i.Height <= currentPassHeight).OrderBy(i => i.Height).FirstOrDefaultAsync(); if (nextBlock == null) { return(processedAny); } height = nextBlock.Height; await ProcessBlockAsync(nextBlock.Height, db, cancellationToken).ConfigureAwait(false); processedAny = true; nextBlock.SharesAveraged = true; await db.SaveChangesAsync(cancellationToken); transaction.Commit(); } } await Messenger.PublishAsync("Block.State.Averaged", this, new BlockStateChangedMessage(height)).ConfigureAwait(false); } }
protected override void DoStartAsync(object stoppingToken) { uart = new UART_Adapter(UARTSettings.COMPort); uart.Open(); Logger.LogInformation($"UART is now listennig port {UARTSettings.COMPort}"); OneWireSensor sensor = new DS18B20(uart); List <byte[]> ROMs = sensor.GetConnectedROMs(); Logger.LogInformation($"{ROMs.Count} connected sensor(s)"); foreach (byte[] item in ROMs) { OneWireSensor physSensor = Utils.CreateSensor(item[0], uart, item); using (var scope = ScopeFactory.CreateScope()) { IUnitOfWork <Sensor> sensorsUnitOfWork = scope.ServiceProvider.GetRequiredService <IUnitOfWork <Sensor> >(); var dbSensor = sensorsUnitOfWork.GetRepository().Query().FirstOrDefault(sn => sn.ROM == physSensor.ROM); if (dbSensor == null) { Sensors.Add(new UARTSensorDTO(physSensor) { SensorID = (Sensors.Count + 1) * -1, Name = "Not in DB", ROM = physSensor.ROM, DeviceName = physSensor.DeviceName(physSensor.FamilyCode) }); } else { Sensors.Add(new UARTSensorDTO(physSensor) { SensorID = dbSensor.snID, Name = dbSensor.Name, ROM = physSensor.ROM, DeviceName = physSensor.DeviceName(physSensor.FamilyCode) }); } Logger.LogInformation($"Added to list sensor with ROM: {physSensor.ROM}, Family Code = {physSensor.FamilyCode}"); } } }
protected override async Task SpecificProcessAction(DtoSmsMessage msg) { using (var scope = ScopeFactory.CreateScope()) { var provider = scope.ServiceProvider; var traceService = provider.GetService <ITraceService>(); await traceService.WriteMessageAsync( $"SMS_SENDER: sending sms for {msg.Phone}"); var settingsService = provider.GetService <ISettingsService>(); var url = settingsService.GetSmsServiceUrl(); var json = JsonConvert.SerializeObject(msg); var httpClient = new HttpClient(); var response = await httpClient.PostAsync($"{url}", new StringContent(json, Encoding.UTF8, "application/json")); if (response.StatusCode != HttpStatusCode.OK) { throw new HttpRequestException($"{response.StatusCode}"); } } }
/// <summary> /// Fetches a list of active messages without changing the state of the receiver or the message source. /// </summary> /// <param name="sequenceNumber">The sequence number from where to peek the message.</param> /// <param name="maxMessages">The maximum number of messages that will be fetched.</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// <returns>An <see cref="IList{ServiceBusReceivedMessage}" /> of messages that were peeked.</returns> private async Task <IList <ServiceBusReceivedMessage> > PeekMessagesInternalAsync( long?sequenceNumber, int maxMessages, CancellationToken cancellationToken) { Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusReceiver)); cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>(); Logger.PeekMessageStart(Identifier, sequenceNumber, maxMessages); using DiagnosticScope scope = ScopeFactory.CreateScope( DiagnosticProperty.PeekActivityName, requestedMessageCount: maxMessages); scope.Start(); IList <ServiceBusReceivedMessage> messages = new List <ServiceBusReceivedMessage>(); try { messages = await InnerReceiver.PeekMessagesAsync( sequenceNumber, maxMessages, cancellationToken) .ConfigureAwait(false); } catch (Exception exception) { Logger.PeekMessageException(Identifier, exception.ToString()); scope.Failed(exception); throw; } Logger.PeekMessageComplete(Identifier, messages.Count); scope.SetMessageData(messages); return(messages); }
private async Task ProcessSingleMessage(Message m) { try { SnsPayload snsPayload; try { snsPayload = JsonConvert.DeserializeObject <SnsPayload>(m.Body); } catch (Exception e) { Logger.LogError(e, $"{nameof(ProcessSingleMessage)} Failed to deserialize snsPayload with ID {m.MessageId}"); snsPayload = null; } if (snsPayload == null) { // Either exception or null deserialization can occur with badly formed Json. // Delete, so they don't just fill up the que var deleteMessage = new DeleteMessageRequest(_url, m.ReceiptHandle); var deleteResponse = await _awSqsClient.DeleteMessageAsync(deleteMessage); Logger.LogWarning($"{nameof(ProcessSingleMessage)} Failed to parse SQS Message. MessageID: {m.MessageId}, Body: {m.Body} Delete SQS Message Response Code: {deleteResponse.HttpStatusCode}"); return; } Logger.LogInformation($"{nameof(ProcessSingleMessage)} Processing SQS Message ID: {m.MessageId}."); // We need to create a scope, as a hosted service is a singleton, but some of the services are transient, we can't inject them. // Instead we create a scope for 'our' work using var serviceScope = ScopeFactory.CreateScope(); var executor = RequestExecutorContainer.Build <TagFileSnsProcessExecutor>( serviceScope.ServiceProvider.GetService <ILoggerFactory>(), serviceScope.ServiceProvider.GetService <IConfigurationStore>(), serviceScope.ServiceProvider.GetService <IDataCache>(), serviceScope.ServiceProvider.GetService <ITRexTagFileProxy>(), serviceScope.ServiceProvider.GetService <ITransferProxyFactory>(), serviceScope.ServiceProvider.GetService <IWebRequest>()); var result = await executor.ProcessAsync(snsPayload); // internalErrors are retry-able, so leave them on the que to be picked up again. if (result != null && result.Code != ContractExecutionStatesEnum.InternalProcessingError) { // Mark as processed var deleteMessage = new DeleteMessageRequest(_url, m.ReceiptHandle); var deleteResponse = await _awSqsClient.DeleteMessageAsync(deleteMessage); Logger.LogInformation($"{nameof(ProcessSingleMessage)} Delete SQS Message Response Code: {deleteResponse.HttpStatusCode}"); } else { Logger.LogWarning($"{nameof(ProcessSingleMessage)} Tag file failed to process due to internal error, leave it on que to be re-processed: {m.MessageId}."); } } catch (Exception e) { Logger.LogError(e, $"{nameof(ProcessSingleMessage)} Failed to process message with ID {m.MessageId} - not deleted from the queue"); } }
protected async Task ImportPaymentsIZettle() { using (var scope = ScopeFactory.CreateScope()) { var db = scope.ServiceProvider.GetService <TandemBookingContext>(); var purchases = await IZettleService.GetPayments(DateTime.Now.AddYears(-1), null); var payments = purchases.Purchases .SelectMany(purchase => purchase.Payments .Select(payment => new { Purchase = purchase, Payment = payment, }) ) .ToList(); var paymentAccounts = db.PaymentAccounts .Where(a => a.PaymentType == PaymentType.IZettle) .ToList(); foreach (var x in payments) { if (!db.Payments.Any(p => p.PaymentType == PaymentType.IZettle && p.ExternalRef == x.Payment.Uuid)) { var paymentAccount = paymentAccounts.FirstOrDefault(a => a.PaymentType == PaymentType.IZettle && a.ExternalRef == x.Purchase.UserId.ToString()); if (paymentAccount == null) { paymentAccount = new PaymentAccount { Active = true, PaymentType = PaymentType.IZettle, ExternalRef = x.Purchase.UserId.ToString(), Name = x.Purchase.UserDisplayName, }; paymentAccounts.Add(paymentAccount); } var payment = new Payment { PaymentType = PaymentType.IZettle, ExternalRef = x.Payment.Uuid, Amount = x.Payment.Amount / 100m, UnreconciledAmount = x.Payment.Amount / 100m, Fee = 0m, PaymentDate = x.Purchase.Timestamp, InsertDate = DateTimeOffset.Now, PaymentAccount = paymentAccount, }; db.Add(payment); } } await db.SaveChangesAsync(); } await Load(); }
public override async Task OnIntervalAsync() { using var scope = ScopeFactory.CreateScope(); var db = scope.ServiceProvider.GetService <UsersDbContext>(); db.RemoveRange(db.Users.Where(x => x.DeleteAt <= DateTime.Today)); await db.SaveChangesAsync(); }
public async Task RemoveAsync <TEntity>(TEntity entity) where TEntity : BaseEntity { using var scope = ScopeFactory.CreateScope(); var repository = scope.ServiceProvider.GetService <IRepository <TEntity> >(); await repository.RemoveAsync(entity); }
private void EnsureDatabase() { using var scope = ScopeFactory.CreateScope(); var context = scope.ServiceProvider.GetService <ApplicationDbContext>(); context.Database.EnsureCreated(); }
public static void EnsureDatabase() { using var scope = ScopeFactory.CreateScope(); var context = scope.ServiceProvider.GetService <ApplicationDbContext>(); context.Database.Migrate(); }
public static async Task <Book> GetBookAsync(string title) { var scope = ScopeFactory.CreateScope(); var context = scope.ServiceProvider.GetService <AppDbContext>(); return(await context.Books .Include(b => b.Authors) .FirstOrDefaultAsync(b => b.Title == title)); }
public static async Task <Card> GetDefaultUserCardAsync() { var scope = ScopeFactory.CreateScope(); var context = scope.ServiceProvider.GetService <AppDbContext>(); return(await context.Cards .Include(c => c.Books) .FirstAsync(c => c.Id == UserCardId)); }