public Orders GetOrdersHeader()
{
using (OrderDataContext oc = UnityContainer.Resolve <OrderDataContext>())
{
string userId = UnityContainer.Resolve <IOrderUserInfo>().Property["USER_ID"];
Orders orders = UnityContainer.Resolve <Orders>();
var ord = (from or in oc.DataBaseContext.vOrderHeaderAll
where or.id_User == new Guid(userId)
select new OrderHeaderObj()
{
CreateDate = or.CreateDate,
IdOrderHeader = or.id_OrderHeader,
IdOrderState = or.id_OrderState.GetValueOrDefault(1),
IdShop = or.id_Shop,
IdUser = or.id_User,
Name = or.Note
}).OrderBy(or => or.CreateDate);
var sdic = (from sd in oc.DataBaseContext.OrderState
select sd);
foreach (var orderHeader in ord)
{
foreach (var orderState in sdic)
{
orderHeader.OrderStateDict.Add(orderState.id, orderState.Name);
}
orderHeader.IdOrderState = orderHeader.IdOrderState;
orders.Add(orderHeader);
}
return(orders);
}
}
private void Load()
{
using (_orderDataContext = UnityContainer.Resolve<OrderDataContext>())
{
var qr = from c in _orderDataContext.DataBaseContext.vGoodsBalance
where c.Date.Date == DateTime.Now.Date
select new GoodsObject() {
Barcode = c.Barcode,
Code = c.Code, Date = c.Date,
FreeBalance = c.FreeBalance.GetValueOrDefault(0),
Group = c.GoodsGroup,
Id = c.id_GoodsBalance,
Measure = c.Measure,
MinOrder = c.MinOrder.GetValueOrDefault(0),
Name = c.Name,
Price = c.Price.GetValueOrDefault(0),
Quantity = c.Balance.GetValueOrDefault(0),
QuantityInPack = c.QuantityInPack.GetValueOrDefault(0),
RequeryQuantity = c.ReqQuantity,
Reserved = c.Reserved.GetValueOrDefault(0),
Supplier = c.Supplier
};
GoodsObjectList = qr.ToList();
}
}
public void Init()
{
this.fakeBus = A.Fake <IBusClient>();
var path1 = Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName;
AppDomain.CurrentDomain.SetData("DataDirectory", Path.Combine(path1, "App_Data"));
// create test data
this.orders = JsonLoad.Orders();
this.restaurants = JsonLoad.Restaurants();
this.users = JsonLoad.User();
order = orders.FirstOrDefault();
this.confirmOrder = JsonLoad.ConfirmOrder();
// setup DbSet
var set = A.Fake <DbSet <OrderService.Data.Model.Order> >(o => o.Implements(typeof(IQueryable <Order>))
.Implements(typeof(IDbAsyncEnumerable <Order>))).SetupData(this.orders);
var setUser = A.Fake <DbSet <OrderService.Data.Model.User> >(o => o.Implements(typeof(IQueryable <User>))
.Implements(typeof(IDbAsyncEnumerable <User>))).SetupData(this.users);
var setRestaurant = A.Fake <DbSet <OrderService.Data.Model.Restaurant> >(o => o.Implements(typeof(IQueryable <Restaurant>))
.Implements(typeof(IDbAsyncEnumerable <Restaurant>))).SetupData(this.restaurants);
// arrange
this.dataContext = A.Fake <Data.OrderDataContext>();
A.CallTo(() => dataContext.Orders.Add(A <Order> .Ignored)).Returns(order);
A.CallTo(() => dataContext.Orders).Returns(set);
A.CallTo(() => dataContext.Users).Returns(setUser);
A.CallTo(() => dataContext.Restaurants).Returns(setRestaurant);
}
public void SubmitOrderRequest(OrderRequest request)
{
using (var db = new OrderDataContext())
{
var order = new OrderEntity
{
ConfirmationEmailAddress = request.ConfirmationEmailAddress,
DateCreated = DateTime.Now,
RequestedDeliveryDate = request.RequestedDeliveryDate,
VendorNumber = request.VendorNumber,
OrderItems = new Collection <OrderItemEntity>()
};
foreach (var item in request.LineItems)
{
var orderItem = new OrderItemEntity
{
ProductIdentifier = item.ProductIdentifier,
Quantity = item.Quanity
};
order.OrderItems.Add(orderItem);
}
db.Orders.Add(order);
db.SaveChanges();
}
}
public async Task <DeleteOrder> Response(MessageDirectory.Request.DeleteOrder request, MessageContext context)
{
DeleteOrder response = new DeleteOrder();
using (OrderDataContext dataContext = new OrderDataContext())
{
var order = await dataContext.Orders.SingleOrDefaultAsync(p => p.Id == request.OrderId);
if (order == null)
{
Exception ex = new Exception("Delete Order : Does not exist");
ex.Data.Add("OrderId", request.OrderId);
throw ex;
}
OrderDeleted orderDeleted = new OrderDeleted()
{
Id = order.Id
};
response.Id = order.Id;
dataContext.Orders.Remove(order);
dataContext.SaveChanges();
await Bus.PublishAsync(orderDeleted);
}
return(response);
}
private void Load()
{
using (_orderDataContext = UnityContainer.Resolve <OrderDataContext>())
{
var qr = from c in _orderDataContext.DataBaseContext.vGoodsBalance
where c.Date.Date == DateTime.Now.Date
select new GoodsObject()
{
Barcode = c.Barcode,
Code = c.Code, Date = c.Date,
FreeBalance = c.FreeBalance.GetValueOrDefault(0),
Group = c.GoodsGroup,
Id = c.id_GoodsBalance,
Measure = c.Measure,
MinOrder = c.MinOrder.GetValueOrDefault(0),
Name = c.Name,
Price = c.Price.GetValueOrDefault(0),
Quantity = c.Balance.GetValueOrDefault(0),
QuantityInPack = c.QuantityInPack.GetValueOrDefault(0),
RequeryQuantity = c.ReqQuantity,
Reserved = c.Reserved.GetValueOrDefault(0),
Supplier = c.Supplier
};
GoodsObjectList = qr.ToList();
}
}
public async Task TestGetItems()
{
OrderDataContext orderDataContext = new OrderDataContext(_connectionString);
var items = await orderDataContext.GetOrderItems(2);
Assert.AreEqual(2, items.Count);
}
public async Task TestGetCustomer()
{
OrderDataContext orderDataContext = new OrderDataContext(_connectionString);
var customer = await orderDataContext.GetCustumer(1);
Assert.AreEqual("UK", customer.Country);
}
public async Task TestGetOrderStatic_Get_Single_Order()
{
OrderDataContext orderDataContext = new OrderDataContext(_connectionString);
var orders = await orderDataContext.GetSingleOrder(2);
Assert.AreEqual(2, orders.Items.Count);
}
private void SetUserProperty()
{
using (OrderDataContext orderDataContext = UnityContainer.Resolve <OrderDataContext>())
{
UnityContainer.Resolve <IOrderUserInfo>().Property =
Utility.StringToDict(orderDataContext.DataBaseContext.GetUser());
}
}
public async Task<ConfirmOrder> Response(MessageDirectory.Request.ConfirmOrder request, MessageContext context)
{
ConfirmOrder response = new ConfirmOrder();
this.dataContext = DataUtility.GetDataContext(dataContext);
using (dataContext)
{
var user = await dataContext.Users.SingleOrDefaultAsync(p => p.Id == request.UserId);
if (user == null)
{
Exception ex = new Exception("User Doesnt not exist");
ex.Data.Add("Email",request.UserId);
throw ex;
}
var restaurant = await dataContext.Restaurants.SingleOrDefaultAsync(p => p.Id == request.RestaurantId);
if (restaurant == null)
{
Exception ex = new Exception("Restaurant Doesnt not exist");
ex.Data.Add("Id", request.RestaurantId);
throw ex;
}
var order = new Order()
{
Amount = request.Amount.Value,
Address = request.Address,
User = user,
Restaurant = restaurant,
CreateDate = DateTime.Now,
PhoneNumber = request.PhoneNumber,
Email = request.Email,
City = request.City,
DeliveryType = (Data.Enum.DeliveryType)request.DeliveryType,
Products = request.Products.Select(p => new Product()
{
ProductId = p.ProductId,
Quantity = p.Quantity
}).ToList(),
};
dataContext.Orders.Add(order);
await dataContext.SaveChangesAsync();
OrderConfirmed orderConfiremd = new OrderConfirmed()
{
Id = order.Id
};
response.id = order.Id;
await Bus.PublishAsync(orderConfiremd);
}
return response;
}
/// <summary>
/// Message to recive a Confirmed Order , Calculate the price and let
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public async Task Consume(OrderConfirmed message, MessageContext context)
{
using (OrderDataContext dataContext = new OrderDataContext())
{
Data.Model.Order order = dataContext.Orders.Include(p => p.Products).SingleOrDefault(p => p.Id == message.Id);
if (order == null)
{
Exception ex = new Exception("Order not found");
ex.Data.Add("OrderId", message.Id);
throw ex;
}
var calcualtePrice = new CalculatePrice()
{
Products = order.Products.Select(p => new Product()
{
ProductId = p.Id,
Quantity = p.Quantity
}).ToList()
};
//Wait for resolve Notified bug in library ticket id #56487 for adding GUID in exchange
//var calculatedPrice = await Bus.RequestAsync<CalculatePrice, MessageDirectory.Response.CalculatePrice>(calcualtePrice);
//order.Amount = calculatedPrice.TotalAmount;
//dataContext.SaveChanges();
var products = order.Products.Select(o => new Product()
{
ProductId = o.ProductId, Quantity = o.Quantity
}).ToList();
var reqProductionInfos = new ProductInfo()
{
Products = products
};
//var resultInfo = await Bus.RequestAsync<ProductInfo, MessageDirectory.Response.ProductInfo>(reqProductionInfos);
OrderReadyToDeliver orderReady = new OrderReadyToDeliver()
{
Address = order.Address,
Amount = order.Amount,
City = order.City,
CreateDate = order.CreateDate,
DeliveryType = (DeliveryType)order.DeliveryType,
Email = order.Email,
PayedAmount = order.Amount,
PhoneNumber = order.PhoneNumber,
//ProductsToPrepare = resultInfo.Products.Select(p => new ProductToPrepare()
//{
// ProductName = p.ProductName,
// Quantity = p.Quantity
//}).ToList()
};
await Bus.PublishAsync(orderReady);
}
}
public OrderDto CreateOrder(CreateOrderDto dto)
{
var order = _mapper.Map <Order>(dto);
order.Customer = _context.GetCustomer(dto.CustomerId);
_orderService.CreateOrder(order);
var orderfromDb = OrderDataContext.LoadOrder(order.Id);
return(_mapper.Map <OrderDto>(orderfromDb));
}
public async Task TestGetOrderByCustomer()
{
OrderDataContext orderDataContext = new OrderDataContext(_connectionString);
var custumer = new Customer
{
Id = 5
};
var orders = await orderDataContext.GetOrdersByCustomer(custumer);
Assert.AreEqual(2, orders.Count);
}
public static OrderDataContext GetDataContext(OrderDataContext dataContext)
{
if (dataContext == null)
{
dataContext = new OrderDataContext();
}
else if (dataContext.IsDisposed)
{
dataContext = new OrderDataContext();
}
return(dataContext);
}
public BindingList <GoodsBalanceObj> GetOrderList()
{
if (_currentOrderHeader != null)
{
using (OrderDataContext oc = UnityContainer.Resolve <OrderDataContext>())
{
List <vGoodsBalanceOrder> orders;
if (StoreHouseType)
{
orders = oc.DataBaseContext.vGoodsBalanceOrder.Where(
or => (((or.id_OrderHeader == _currentOrderHeader.IdOrderHeader) ||
(or.id_OrderHeader == null)) && (or.GoodsGroup != @"АЛКОГОЛЬНЫЕ НАПИТКИ"))).ToList();
}
else
{
orders = oc.DataBaseContext.vGoodsBalanceOrder.Where(
or => (((or.id_OrderHeader == _currentOrderHeader.IdOrderHeader) ||
(or.id_OrderHeader == null)) && (or.GoodsGroup == @"АЛКОГОЛЬНЫЕ НАПИТКИ"))).ToList();
}
BindingList <GoodsBalanceObj> balance = new BindingList <GoodsBalanceObj>();
balance.AllowEdit = _currentOrderHeader.IdOrderState == 1;
foreach (var vo in orders)
{
GoodsBalanceObj bl = new GoodsBalanceObj()
{
Barcode = vo.Barcode,
Code = vo.Code,
Date = vo.Date,
FreeBalance = vo.FreeBalance.GetValueOrDefault(),
Group = vo.GoodsGroup,
id = vo.id_GoodsBalance,
Measure = vo.Measure,
MinOrder = vo.MinOrder.GetValueOrDefault(),
Name = vo.Name,
Price = vo.Price.GetValueOrDefault(),
ReqQuantity = vo.ReqQuantity,
Ordered = vo.Ordered.GetValueOrDefault(),
Quantity = vo.Balance.GetValueOrDefault(),
QuantityInPack = vo.QuantityInPack.GetValueOrDefault(),
Reserved = vo.Reserved.GetValueOrDefault(),
Supplier = vo.Supplier
};
bl.ChangeReqQuantity += new ChangeReqQuantity(bl_ChangeReqQuantity);
balance.Add(bl);
}
return(balance);
}
}
return(null);
}
public async Task CreateOrderTest_AU()
{
// Arrange
TaxDataContext countryTaxDataContext = new TaxDataContext(_connectionString);
OrderDataContext orderDataContext = new OrderDataContext(_connectionString);
ITaxRepository taxRepository = new TaxRepository(countryTaxDataContext);
IOrderRepository orderRepository = new OrderRepository(orderDataContext);
ITaxCalculator taxCalculator = new TaxCalculator(taxRepository);
IOrderCalculationService orderCalculation = new OrderCalculationService(taxCalculator);
IOrderService orderService = new OrderService(orderRepository, orderCalculation);
var date = DateTime.Now;
var orderIdStr = date.Hour.ToString() + date.Minute.ToString() + date.Second.ToString() + date.Millisecond.ToString();
int orderIdUK = int.Parse(orderIdStr);
var orderUK = new Order();
orderUK.Id = orderIdUK;
orderUK.Customer = new Customer()
{
Id = 1,
Country = "AU"
};
orderUK.Items = new List <orderItem>()
{
new orderItem()
{
Code = "D",
Description = "Product D",
Price = 10,
Quantity = 1
},
new orderItem()
{
Code = "E",
Description = "Product E",
Price = 20,
Quantity = 1
}
};
//Act
orderService.CreateOrder(orderUK);
var singleOrderUk = await orderService.ViewOrderAsyn(orderUK.Id);
//Assert
Assert.AreEqual(33, singleOrderUk.Total);
}
void Load()
{
using (OrderDataContext oc = unityContainer.Resolve <OrderDataContext>())
{
var minorder = from m in oc.DataBaseContext.ShopCategory
select new ShopCategoryObj(m.CategoryName, m.id);
foreach (ShopCategoryObj obj in minorder)
{
Add(obj);
}
}
}
public async Task Consume(RestaurantDeleted message, MessageContext context)
{
this.dataContext = DataUtility.GetDataContext(dataContext);
using (dataContext)
{
Restaurant restaurant = dataContext.Restaurants.SingleOrDefault(p => p.Id == message.Id);
if (restaurant == null)
{
throw new Exception($"restaurant Delete : not found by Code {message.Code} by Id {message.Id}");
}
dataContext.Restaurants.Remove(restaurant);
await dataContext.SaveChangesAsync();
}
}
public async Task testGetOrdersByCustemers()
{
OrderDataContext orderDataContext = new OrderDataContext(_connectionString);
var customer = new Customer()
{
Id = 5,
Country = "BR"
};
var orders = await orderDataContext.GetOrdersByCustomer(customer);
Assert.AreEqual(2, orders.Count);
Assert.AreEqual(1, orders[0].Items.Count);
Assert.AreEqual(1, orders[1].Items.Count);
}
public void Init()
{
this.busFake = A.Fake <IBusClient>();
var path1 = Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName;
AppDomain.CurrentDomain.SetData("DataDirectory", Path.Combine(path1, "App_Data"));
// create test data
this.user = JsonLoad.User();
var set = A.Fake <DbSet <User> >(o => o.Implements(typeof(IQueryable <User>)).Implements(typeof(IDbAsyncEnumerable <User>))).SetupData(user);
// setup DbSet
// arrange
this.dataContext = A.Fake <Data.OrderDataContext>();
A.CallTo(() => dataContext.Users).Returns(set);
}
public async Task Consume(UserDeleted message, MessageContext context)
{
this.dataContext = DataUtility.GetDataContext(dataContext);
using (dataContext)
{
User user = dataContext.Users.SingleOrDefault(p => p.Email == message.Email);
if (user == null)
{
Exception ex = new Exception("User Created : not found by Email");
ex.Data.Add("Email", message.Email);
throw ex;
}
dataContext.Users.Remove(user);
await dataContext.SaveChangesAsync();
}
}
public void Load()
{
using (_orderDataContext = UnityContainer.Resolve<OrderDataContext>())
{
var qr = from c in _orderDataContext.DataBaseContext.OrderHeader
join st in _orderDataContext.DataBaseContext.OrderState on c.id_OrderState equals st.id
where c.CreateDate.Date == DateTime.Now.Date
select new OrderHeaderObject()
{
Id = c.id,
OrderDate = c.CreateDate,
ProcessOrderDate = c.ProcesDate,
State = c.id_OrderState.GetValueOrDefault(),
StateName = st.Name
};
OrderHeaderObjectList = qr.ToList();
}
}
public void Load()
{
using (_orderDataContext = UnityContainer.Resolve <OrderDataContext>())
{
var qr = from c in _orderDataContext.DataBaseContext.OrderHeader
join st in _orderDataContext.DataBaseContext.OrderState on c.id_OrderState equals st.id
where c.CreateDate.Date == DateTime.Now.Date
select new OrderHeaderObject()
{
Id = c.id,
OrderDate = c.CreateDate,
ProcessOrderDate = c.ProcesDate,
State = c.id_OrderState.GetValueOrDefault(),
StateName = st.Name
};
OrderHeaderObjectList = qr.ToList();
}
}
void SaveOrder(GoodsBalanceObj goodsObj)
{
{
using (OrderDataContext oc = UnityContainer.Resolve <OrderDataContext>())
{
oc.DataBaseContext.spCreateOrderNew(goodsObj.id, IdOrderHeader, goodsObj.ReqQuantity);
IQueryable <vGoodsBalanceOrder> gods = from gd in oc.DataBaseContext.vGoodsBalanceOrder
where (gd.id_OrderHeader == IdOrderHeader &&
gd.id_GoodsBalance == goodsObj.id)
select gd;
foreach (var gd in gods)
{
goodsObj.Ordered = gd.Ordered.GetValueOrDefault(0);
goodsObj.Quantity = gd.Balance.GetValueOrDefault(0);
}
}
}
}
public void GetOrdersByCustomerId_CustomerIdProvided_OrderQueryIsBeingExecuted()
{
var orderDataContext = new OrderDataContext();
var orderQueries = new Mock <IOrderQueries>();
var sqlConnectionFactory = new Mock <ISqlConnectionFactory>();
var sqlConnection = new Mock <IDbConnection>();
var dbTransaction = new Mock <IDbTransaction>();
sqlConnection.Setup(e => e.BeginTransaction()).Returns(dbTransaction.Object);
sqlConnectionFactory.Setup(e => e.GetSqlConnection(It.IsAny <string>())).Returns(sqlConnection.Object);
OrderDataContext.SqlConnectionFactory = sqlConnectionFactory.Object;
OrderDataContext.OrderQueries = orderQueries.Object;
var anyId = 1;
orderDataContext.GetOrdersByCustomerId(anyId);
orderQueries.Verify(e => e.GetOrdersByCustomerId(It.IsAny <IDbConnection>(), anyId), Times.Exactly(1));
}
public BindingList <GoodsBalanceObj> GetOrderList()
{
if (_currentOrderHeader != null)
{
using (OrderDataContext oc = UnityContainer.Resolve <OrderDataContext>())
{
List <vOrderDayAll> orders = oc.DataBaseContext.vOrderDayAll.Where(
or => (((or.id_OrderHeader == _currentOrderHeader.IdOrderHeader)
))).ToList();
BindingList <GoodsBalanceObj> balance = new BindingList <GoodsBalanceObj>();
balance.AllowEdit = _currentOrderHeader.IdOrderState == 1;
foreach (var vo in orders)
{
GoodsBalanceObj bl = new GoodsBalanceObj()
{
Barcode = vo.Barcode,
Code = vo.Code,
Date = vo.Date,
FreeBalance = vo.FreeBalance.GetValueOrDefault(),
Group = vo.GoodsGroup,
id = vo.id_GoodsBalance,
Measure = vo.Measure,
MinOrder = vo.MinOrder.GetValueOrDefault(),
Name = vo.Name,
Price = vo.Price.GetValueOrDefault(),
ReqQuantity = vo.ReqQuantity,
Ordered = vo.Ordered,
Quantity = vo.Balance,
QuantityInPack = vo.QuantityInPack.GetValueOrDefault(),
Reserved = vo.Reserved.GetValueOrDefault(),
Supplier = vo.Supplier
};
balance.Add(bl);
}
return(balance);
}
}
return(null);
}
public void CreateOrder_TwoInsertMethods_InsertMethodAreBeingExecuted()
{
var orderDataContext = new OrderDataContext();
var orderCommands = new Mock <IOrderCommands>();
var sqlConnectionFactory = new Mock <ISqlConnectionFactory>();
var sqlConnection = new Mock <IDbConnection>();
var dbTransaction = new Mock <IDbTransaction>();
sqlConnection.Setup(e => e.BeginTransaction()).Returns(dbTransaction.Object);
sqlConnectionFactory.Setup(e => e.GetSqlConnection(It.IsAny <string>())).Returns(sqlConnection.Object);
OrderDataContext.SqlConnectionFactory = sqlConnectionFactory.Object;
orderDataContext.OrderCommands = orderCommands.Object;
var order = new Order();
orderDataContext.CreateOrder(order);
orderCommands.Verify(e => e.AddOrder(It.IsAny <Order>(), It.IsAny <IDbConnection>()), Times.Exactly(1));
orderCommands.Verify(e => e.AddOrderItems(It.IsAny <Order>(), It.IsAny <IDbConnection>()), Times.Exactly(1));
}
private static void Main(string[] args)
{
var path1 = Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName;
AppDomain.CurrentDomain.SetData("DataDirectory", Path.Combine(path1, "App_Data"));
using (OrderDataContext test = new OrderDataContext())
{
var result = test.Users.FirstOrDefault();
}
HostFactory.Run(x =>
{
x.Service <ServiceWindsor>();
x.RunAsLocalSystem();
x.SetDescription("Order Service");
x.SetDisplayName("OrderService");
x.SetServiceName("OrderService");
});
}
public async Task Consume(RestaurantCreated message, MessageContext context)
{
this.dataContext = DataUtility.GetDataContext(dataContext);;
using (dataContext)
{
Restaurant restaurant = dataContext.Restaurants.SingleOrDefault(p => p.Id == message.Id);
if (restaurant != null)
{
return;
}
restaurant = new Restaurant
{
Id = message.Id,
Code = message.Code
};
dataContext.Restaurants.Add(restaurant);
await dataContext.SaveChangesAsync();
}
}
public async Task <OrderList> Response(DirectoryMessage.Request.OrderList request)
{
OrderList response = new OrderList();
using (OrderDataContext context = new OrderDataContext())
{
var orders = await context.Orders.Where(p => (request.UserId == null || p.UserId == request.UserId) && (request.RestaurantId == null || p.RestaurantId == request.RestaurantId)).ToListAsync();
response.Items = orders.Select(o => new OrderInfo()
{
UserId = o.UserId, RestaurantId = o.RestaurantId, Address = o.Address,
Amount = o.Amount, City = o.City, ConfirmationDate = o.ConfirmationDate,
DeliveryType = (DeliveryType)o.DeliveryType, Email = o.Email, Id = o.Id, PhoneNumber = o.PhoneNumber,
Products = o.Products.Select(p => new FDP.OrderService.DirectoryMessage.Shared.Product()
{
ProductId = p.ProductId, Quantity = p.Quantity
}).ToList()
}).ToList();
}
return(response);
}
public async Task Consume(UserCreated message, MessageContext context)
{
this.dataContext = DataUtility.GetDataContext(dataContext);
using (dataContext)
{
User user = dataContext.Users.SingleOrDefault(p => p.Email == message.Email);
if (user != null)
{
return;
}
user = new User
{
Id = message.Id,
Email = message.Email,
Username = message.Username
};
dataContext.Users.Add(user);
await dataContext.SaveChangesAsync();
}
}
