public async Task DeliveryContext_Current_differs_per_async_context()
{
var barrier = new Barrier(2);
string commandInTask1 = null;
string commandInTask2 = null;
await Task.Run(() =>
{
using (DeliveryContext.Establish(
new CommandDelivery <string>("", idempotencyToken: "one")))
{
barrier.SignalAndWait(1000);
commandInTask1 = DeliveryContext.Current.Delivery.IdempotencyToken;
}
});
await Task.Run(() =>
{
using (DeliveryContext.Establish(
new CommandDelivery <string>("", idempotencyToken: "two")))
{
barrier.SignalAndWait(1000);
commandInTask2 = DeliveryContext.Current.Delivery.IdempotencyToken;
}
});
commandInTask1.Should().Be("one");
commandInTask2.Should().Be("two");
}
void DeliverWithDelay(DeliveryContext <GrpcTransportMessage> context)
{
Task.Run(async() =>
{
var delayed = false;
try
{
var delay = context.Message.EnqueueTime.Value - DateTime.UtcNow;
if (delay > TimeSpan.Zero)
{
_metrics.DelayedMessageCount.Add();
delayed = true;
await Task.Delay(delay, Stopping).ConfigureAwait(false);
}
await _channel.Writer.WriteAsync(context, Stopping).ConfigureAwait(false);
_metrics.MessageCount.Add();
}
catch (OperationCanceledException)
{
}
catch (Exception exception)
{
LogContext.Error?.Log(exception, "Message delivery faulted: {Queue}", _name);
}
finally
{
if (delayed)
{
_metrics.DelayedMessageCount.Remove();
}
}
}, context.CancellationToken);
}
public async Task SeedAsync(DeliveryContext context, IWebHostEnvironment webHostEnvironment)
{
var policy = CreatePolicy(nameof(DeliveryContextSeed));
await policy.ExecuteAsync(async() =>
{
using (context)
{
if (!context.DeliveryStatuses.Any())
{
context.DeliveryStatuses.AddRange(GetPredefinedDeliveryStatus());
await context.SaveChangesAsync();
}
//TODO: Only for demo purposes
if (!context.Clients.Any())
{
var identityGuid = Guid.NewGuid();
var client = new Client(identityGuid, "ClientFirstName", "ClientLastName", "+123456789");
context.Clients.Add(client);
await context.SaveChangesAsync();
}
await context.SaveEntitiesAsync();
}
});
}
public void Token_algorithm_should_not_change()
{
// if this test fails then it indicates that the sequential etag algorithm has changed
var etagSequenceProducedByPreviousVersion = new[]
{
"7sNkA6fd+WqICHfZpSpca2bETG9e3AV0gwZP5/6zkVA=", "KJYYEMLms/h7kNhd8bmrrEhuGWFYAyMCr9UGtPR9kTY=",
"SWS6CjQM9taGbF3eYnG6xYrd5gkQyKa9b5KJg3o2YfQ=", "LtN9an7jOaKR3LShgocAH2edLzj8FGTuQ8z9wvMFzjg=",
"Yl/xj5eSYvywL8basZi0hsBYLWmAki6BG9KfbnpuYuc=", "qUEIZJOFwsI29ISwn25y2kstLOx//NSfVc76hY+KsEM=",
"2UDKYnVH6sBfnEn0mAXMb1clOayxhqA4wjLoXRYhuV0=", "vzQI9iIC6sQqD/Dk0D3ugVyjrvDeM7FoH+v2Y9H/emA=",
"iCqOdnu3UnIN68fVQyqZd9AD/PpW8+Qc2fkGT+9PUkc=", "EkHe5MMDkZkJiapyKEfSbKG6XuWhhZZLtD2UUlUML54="
};
var newlyGeneratedSequence = new List <string>();
var token = "some specific token";
using (var ctx = DeliveryContext.Establish(new CommandDelivery <string>("hello", idempotencyToken: "some specific value")))
{
Enumerable.Range(1, 10).ToList().ForEach(_ => newlyGeneratedSequence.Add(ctx.NextToken(token)));
}
newlyGeneratedSequence
.Should()
.BeEquivalentTo(etagSequenceProducedByPreviousVersion);
}
public void GetCategories_WhenCalledWithInMemoryDataContext_ReturnsExpectedResult()
{
// arrange
var inMemoryDataContextOptions = new DbContextOptionsBuilder <DeliveryContext>()
.UseInMemoryDatabase(databaseName: "Test_With_In_Memory_Database")
.Options;
// act
var DeliveryContext = new DeliveryContext(inMemoryDataContextOptions);
// Assign values to category object and this object store in memory database
var category = new Category()
{
Name = "Test1", Description = "Description Test1", RestaurantID = 1
};
DeliveryContext.Categories.Add(category);
DeliveryContext.SaveChanges();
// Initialize CategoriesController and put our inMemory context to its constructor
var controller = new CategoriesController(DeliveryContext);
//assert
//Getting list of categories
var returnData = controller.GetCategories();
// We confirm here the return list is of type category + confirm data will return back or not
List <Category> returnValue = Assert.IsType <List <Category> >(returnData.Result.Value);
Assert.True(returnValue.FirstOrDefault().Name == "Test1");
}
public void GetOrderAssignment_WhenCalledWithInMemoryDataContext_ReturnsExpectedResult()
{
// arrange
var inMemoryDataContextOptions = new DbContextOptionsBuilder <DeliveryContext>()
.UseInMemoryDatabase(databaseName: "Test_With_In_Memory_Database")
.Options;
var DeliveryContext = new DeliveryContext(inMemoryDataContextOptions);
// act
var list = new List <OrderAssignmentReason>()
{
new OrderAssignmentReason {
Reason = "Test1", Description = "Test1 Description"
},
new OrderAssignmentReason {
Reason = "Test2", Description = "Test2 Description"
}
};
DeliveryContext.OrderAssignmentReasons.AddRange(list);
DeliveryContext.SaveChanges();
// Initialize OrderAssignmentReasonsController -> inMemory context to its constructor
var controller = new OrderAssignmentReasonsController(DeliveryContext);
//assert
//Getting list of OrderAssignmentReasons
var returnData = controller.GetOrderAssignmentReasons();
// We confirm here the return list is of type OrderAssignmentReason and also confirm data will return back or not
List <OrderAssignmentReason> returnValue = Assert.IsType <List <OrderAssignmentReason> >(returnData.Result.Value);
// Confirming here the count should be two as we are adding above two objects in inMemory database
Assert.True(returnValue.Count == 2);
}
public void PutOrder_WhenCalledWithInMemoryDataContext_ReturnsExpectedResult()
{
// arrange
var inMemoryDataContextOptions = new DbContextOptionsBuilder <DeliveryContext>()
.UseInMemoryDatabase(databaseName: "Test_With_In_Memory_Database")
.Options;
// act
var DeliveryContext = new DeliveryContext(inMemoryDataContextOptions);
// Assign values to Orders object and this object store in memory database
var order = new Order()
{
ID = 1, CustomerID = 1, DriverID = 1, LocationID = 1, PreparerID = 1
};
DeliveryContext.Orders.Add(order);
DeliveryContext.SaveChanges();
// Initialize OrdersController and put our inMemory context to its constructor
var controller = new OrdersController(DeliveryContext);
//assert
//passing object for post method
var returnData = controller.PutOrder(1, order);
// We are confirming here the PutOrder() method should return nothing as no content.
Assert.NotNull(returnData.Result);
}
public void Save()
{
var options = new DbContextOptionsBuilder <DeliveryContext>()
.UseInMemoryDatabase(databaseName: "test")
.Options;
var obj = new DeliveryServiceModel()
{
BaseCost = 100,
Distance = 30,
Floor = 4,
GoldRated = false,
HasCoupen = false,
NewCustomer = false,
WeekendDelivery = false
};
using (var context = new DeliveryContext(options))
{
var adapter = new DeliveryServiceAdapter(context);
var results = adapter.Save(obj);
Assert.IsNotNull(results.id);
}
}
public void CheckDeleteAddress_WhenCalledWithInMemoryDataContext_ReturnsExpectedResult()
{
// arrange
var inMemoryDataContextOptions = new DbContextOptionsBuilder <DeliveryContext>()
.UseInMemoryDatabase(databaseName: "Test_With_In_Memory_Database")
.Options;
// act
var DeliveryContext = new DeliveryContext(inMemoryDataContextOptions);
// Assign values to address object -> this object store in memory database
var address = new Address()
{
Address1 = "Test1", Address2 = "Test2", City = "Lahore", State = "Punjab", ZipCode = "54000"
};
DeliveryContext.Addresses.Add(address);
DeliveryContext.SaveChanges();
// Initialize AddressesController and put our inMemory context to its constructor
var controller = new AddressesController(DeliveryContext);
//ASSERT
//check Addresses is exist or not
var returnData = controller.DeleteAddress(1);
// We are confirming here the deleted object is of type address.
Assert.IsType <Address>(returnData.Result.Value);
}
public void CheckCategoryIsExist_WhenCalledWithInMemoryDataContext_ReturnsExpectedResult()
{
//Setup in memory database
var inMemoryDataContextOptions = new DbContextOptionsBuilder <DeliveryContext>()
.UseInMemoryDatabase(databaseName: "Test_With_In_Memory_Database")
.Options;
// we need to seed the in-memory test database
var DeliveryContext = new DeliveryContext(inMemoryDataContextOptions);
// Assign values to category object and this object store in memory database
var category = new Category()
{
Name = "Test1", Description = "Description Test1", RestaurantID = 1
};
DeliveryContext.Categories.Add(category);
DeliveryContext.SaveChanges();
// Initialize CategoriesController and put our inMemory context to its constructor
var controller = new CategoriesController(DeliveryContext);
//assert
//check category is exist or not
var returnData = controller.CategoryExists(1); //auto-generate from teh DB is 1 since we only created 1 record
// We are confirming here the category is exist or not, actually CategoryExists return as true or false.
Assert.True(returnData == true);
}
public void Nested_command_contexts_maintain_independent_token_sequences()
{
var sourceToken = Guid.NewGuid().ToString();
var outerCommand = new CommandDelivery <string>("");
var sequenceWithoutInnerContext = new List <string>();
var sequenceWithInnerContext = new List <string>();
using (var context = DeliveryContext.Establish(outerCommand))
{
sequenceWithoutInnerContext.Add(context.NextToken(sourceToken));
sequenceWithoutInnerContext.Add(context.NextToken(sourceToken));
}
using (var outerContext = DeliveryContext.Establish(outerCommand))
{
sequenceWithInnerContext.Add(outerContext.NextToken(sourceToken));
using (var innerCtx = DeliveryContext.Establish(
new CommandDelivery <object>(
new object(), idempotencyToken: Guid.NewGuid().ToString())))
{
innerCtx.NextToken(Guid.NewGuid().ToString());
}
sequenceWithInnerContext.Add(outerContext.NextToken(sourceToken));
}
sequenceWithInnerContext.Should().Equal(sequenceWithoutInnerContext);
}
public DeliveryService(DeliveryContext context, HttpClient httpClient)
{
this.context = context;
_apiClient = httpClient;
//_documenturl = $"{_settings.Value.DocumentUrl}/api/v1/document";
_documenturl = "https://localhost:5001/api/v1/document";
//_forwardingurl = $"{_settings.Value.ForwardingUrl}/api/v1/forwardings";
}
public Task Deliver(DeliveryContext <InMemoryTransportMessage> context)
{
return(context.WasAlreadyDelivered(this)
? Task.CompletedTask
: context.Message.Delay > TimeSpan.Zero
? DeliverWithDelay(context)
: _executor.Push(() => DispatchMessage(context), context.CancellationToken));
}
public TransactionBehaviour(DeliveryContext dbContext,
IDeliveryIntegrationEventService deliveryIntegrationEventService,
ILogger <TransactionBehaviour <TRequest, TResponse> > logger)
{
_dbContext = dbContext ?? throw new ArgumentException(nameof(DeliveryContext));
_deliveryIntegrationEventService = deliveryIntegrationEventService ??
throw new ArgumentException(nameof(deliveryIntegrationEventService));
_logger = logger ?? throw new ArgumentException(nameof(ILogger));
}
public WebhookEvent(WebhookEventType type, WebhookEventSource source, long timestamp, string mode, string webhookEventId, DeliveryContext deliveryContext)
{
Type = type;
Source = source;
Timestamp = timestamp;
Mode = mode;
WebhookEventId = webhookEventId;
DeliveryContext = deliveryContext;
}
public void peula()
{
using (var ctx = new DeliveryContext())
{
//var deliver = new Delivery() { Code = 1 };
//ctx.Deliveries.Add(deliver);
ctx.SaveChanges();
}
}
public async Task Deliver(DeliveryContext <GrpcTransportMessage> context, string routingKey)
{
if (_children.TryGetValue("#", out var hashNode))
{
await hashNode.Deliver(context, default).ConfigureAwait(false);
}
if (string.IsNullOrWhiteSpace(routingKey))
{
await _sinks.ForEachAsync(async sink =>
{
if (context.WasAlreadyDelivered(sink))
{
return;
}
await sink.Deliver(context).ConfigureAwait(false);
context.Delivered(sink);
}).ConfigureAwait(false);
}
else
{
var separator = routingKey.IndexOf('.');
if (separator < 0)
{
if (_children.TryGetValue("*", out var starNode))
{
await starNode.Deliver(context, default).ConfigureAwait(false);
}
if (_children.TryGetValue(routingKey, out var childNode))
{
await childNode.Deliver(context, default).ConfigureAwait(false);
}
}
else
{
var word = routingKey.Substring(0, separator);
var remaining = routingKey.Substring(separator + 1);
if (_children.TryGetValue("*", out var starNode))
{
await starNode.Deliver(context, remaining).ConfigureAwait(false);
}
if (_children.TryGetValue(word, out var childNode))
{
await childNode.Deliver(context, remaining).ConfigureAwait(false);
}
}
}
}
static void Main(string[] args)
{
using (var ctx = new DeliveryContext())
{
var adult = new Adult()
{
Id = "123456"
};
ctx.Adults.Add(adult);
ctx.SaveChanges();
}
// Accord.Math.Random.Generator.Seed = 0;
// // A common desire when doing clustering is to attempt to find how to
// // weight the different components / columns of a dataset, giving them
// // different importances depending on the end goal of the clustering task.
// // Declare some observations
// double[][] observations =
// {
// new double[] { -5, -2, -1 },
// new double[] { -5, -5, -6 },
// new double[] { 2, 1, 1 },
// new double[] { 1, 1, 2 },
// new double[] { 1, 2, 2 },
// new double[] { 3, 1, 2 },
// new double[] { 11, 5, 4 },
// new double[] { 15, 5, 6 },
// new double[] { 10, 5, 6 },
//};
// // Create a new K-Means algorithm
// KMeans kmeans = new KMeans(k: 3)
// {
// // For example, let's say we would like to consider the importance of
// // the first column as 0.1, the second column as 0.7 and the third 0.9
// Distance = new WeightedSquareEuclidean(new double[] { 0.1, 0.7, 1.1 })
// };
// // Compute and retrieve the data centroids
// var clusters = kmeans.Learn(observations);
// // Use the centroids to parition all the data
// int[] labels = clusters.Decide(observations);
// // for(int i=0;i<labels.Length;i++)
// foreach(var a in clusters)
// {
// // Console.WriteLine(a.);
// }
}
public void Init()
{
context = TestDataContext.GetContextWithData();
appSettings = new Mock <IOptions <AppSettings> >();
appSettings.SetupGet(x => x.Value)
.Returns(new AppSettings
{
Key = "This_Is_My_Secret_Key"
});
userService = new UserService(appSettings.Object, context);
}
public Task Deliver(DeliveryContext <InMemoryTransportMessage> context)
{
if (context.WasAlreadyDelivered(this))
{
return(Task.FromResult(false));
}
Interlocked.Increment(ref _queueDepth);
Task.Factory.StartNew(() => DispatchMessage(context.Package), _cancellationToken.Token, TaskCreationOptions.None, _scheduler);
return(Task.FromResult(true));
}
async Task DispatchMessage(DeliveryContext <InMemoryTransportMessage> context)
{
await _consumer.Task.OrCanceled(context.CancellationToken).ConfigureAwait(false);
try
{
await _consumers.ForEachAsync(x => x.Consume(context.Message, context.CancellationToken)).ConfigureAwait(false);
}
// ReSharper disable once EmptyGeneralCatchClause
catch
{
}
}
public void A_series_of_calls_to_NextToken_produces_a_different_token_per_call()
{
var token = Guid.NewGuid().ToString();
var tokens = new List <string>();
using (var ctx = DeliveryContext.Establish(new CommandDelivery <string>("hi!")))
{
Enumerable.Range(1, 100).ToList().ForEach(_ => tokens.Add(ctx.NextToken(token)));
}
tokens.Distinct().Should().HaveCount(100);
}
public static void Main(string[] args)
{
CreateWebHostBuilder(args).Build().Run();
using (DeliveryContext db = new DeliveryContext())
{
var users = db.Users.ToList();
Console.WriteLine("List of objects:");
foreach (User u in users)
{
Console.WriteLine($"{u.Id}.{u.Email} - {u.Password}-{u.FirstName}-{u.LastName}-{u.Phone}-{u.SubscriptionStatus}-{u.IdRole}-{u.IdCarrier}-{u.IdCompany}");
}
}
Console.ReadKey();
}
public async Task Deliver(DeliveryContext <GrpcTransportMessage> context)
{
await _sinks.ForEachAsync(async sink =>
{
if (context.WasAlreadyDelivered(sink))
{
return;
}
await sink.Deliver(context).ConfigureAwait(false);
context.Delivered(sink);
}).ConfigureAwait(false);
}
public async Task Deliver(DeliveryContext <InMemoryTransportMessage> context)
{
foreach (IMessageSink <InMemoryTransportMessage> sink in _sinks)
{
if (context.WasAlreadyDelivered(sink))
{
continue;
}
await sink.Deliver(context).ConfigureAwait(false);
context.Delivered(sink);
}
}
public DeliveryIntegrationEventService(IEventBus eventBus,
DeliveryContext deliveryContext,
IntegrationEventLogContext eventLogContext,
Func <DbConnection, IIntegrationEventLogService> integrationEventLogServiceFactory,
ILogger <DeliveryIntegrationEventService> logger)
{
_deliveryContext = deliveryContext ?? throw new ArgumentNullException(nameof(deliveryContext));
var integrationEventLogServiceFactory1 = integrationEventLogServiceFactory ??
throw new ArgumentNullException(
nameof(integrationEventLogServiceFactory));
_eventBus = eventBus ?? throw new ArgumentNullException(nameof(eventBus));
_eventLogService = integrationEventLogServiceFactory1(_deliveryContext.Database.GetDbConnection());
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public static DeliveryContext GetContextWithData()
{
var options = new DbContextOptionsBuilder <DeliveryContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var context = new DeliveryContext(options);
var deliverys = DataGenerator.GetDeliveries();
context.Users.AddRange(DataGenerator.GetUsers());
context.Deliveries.AddRange(deliverys);
context.SaveChanges();
return(context);
}
public async Task Deliver(DeliveryContext <GrpcTransportMessage> context)
{
if (_sinks.TryGetValue(context.Message.RoutingKey ?? "", out Connectable <IMessageSink <GrpcTransportMessage> > forKey))
{
await forKey.ForEachAsync(async sink =>
{
if (context.WasAlreadyDelivered(sink))
{
return;
}
await sink.Deliver(context).ConfigureAwait(false);
context.Delivered(sink);
}).ConfigureAwait(false);
}
}
Task DeliverWithDelay(DeliveryContext <InMemoryTransportMessage> context)
{
Task.Run(async() =>
{
try
{
await Task.Delay(context.Message.Delay.Value, _source.Token).ConfigureAwait(false);
await _executor.Push(() => DispatchMessage(context), _source.Token).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
}
}, context.CancellationToken);
return(Task.CompletedTask);
}
public static void Initialize(IServiceProvider serviceProvider)
{
using (var context = new DeliveryContext(
serviceProvider.GetRequiredService <DbContextOptions <DeliveryContext> >()))
{
if (context.Deliveries.Any())
{
return; // Data was already seeded
}
var deliveries = GetDeliveries();
context.Users.AddRange(GetUsers());
context.Deliveries.AddRange(deliveries);
context.SaveChanges();
}
}
public DeliveryStore(DeliveryContext context)
{
this.context = context;
}