/// <summary>
/// Add order to area.
/// </summary>
/// <param name="file">Order to add.</param>
/// <param name="currentUserId">Id of current user.</param>
/// <returns>
/// Added order.
/// </returns>
/// <exception cref="System.ArgumentException">When one of params invalid.</exception>
/// <exception cref="UnauthorizedAccessException">When customer id != user id</exception>
public async Task <OrderToReturn> AddOrder(OrderToAdd order, string currentUrl, long currentUserId)
{
order.CheckArgumentException();
var user = await _userRepository.GetAsync(currentUserId);
order = order.CustomerId == user.Id
? order
: throw new UnauthorizedAccessException();
var attachments = await SaveFiles(order.Attachments, currentUrl, Defines.FileFolders.ORDER_ATTACHMENTS_FOLDER);
var savedOrder = await _orderRepository.AddAsync(order);
var skills = new List <Skill>();
if (order.Skills != null)
{
foreach (var skill in order.Skills)
{
await _orderSkillRepository.AddAsync(new OrderSkill
{
OrderId = order.Id,
SkillId = skill.Id
});
}
}
return(savedOrder.ConvertOrderToReturn(attachments, skills));
}
public ProvisionShould()
{
customerRepositoryMock = new Mock <ICustomerRepository>();
mobileRepositoryMock = new Mock <IRepository <Mobile> >();
guidCreatorMock = new Mock <IGuidCreator>();
monitoringMock = new Mock <IMonitoring>();
customersServiceMock = new Mock <ICustomersService>();
var loggingMock = new Mock <ILogger <CustomersController> >();
var getMobilesByCustomerIdQueryMock = new Mock <IGetMobilesByCustomerIdQuery>();
var dateTimeCreatorMock = new Mock <IDateTimeCreator>();
expectedOrderToAdd = new OrderToAdd
{
Name = "Neil Armstrong",
ContactPhoneNumber = "01234 123123"
};
expectedCustomerGlobalId = Guid.NewGuid();
expectedMobile = new Mobile(dateTimeCreatorMock.Object, new MobileDataEntity()
{
Id = 101,
GlobalId = Guid.NewGuid(),
CustomerId = expectedCustomerGlobalId,
State = Mobile.MobileState.New.ToString()
});
customersServiceMock.Setup(x => x.Provision(expectedCustomerGlobalId, expectedOrderToAdd))
.Returns(expectedMobile);
sut = new CustomersController(customerRepositoryMock.Object,
mobileRepositoryMock.Object,
monitoringMock.Object,
getMobilesByCustomerIdQueryMock.Object,
customersServiceMock.Object);
}
public void ReturnNewMobile()
{
var dateTimeCreatorMock = new Mock <IDateTimeCreator>();
var expectedGuid = Guid.NewGuid();
var expectedId = 0;
var expectedInProgressOrderGuid = Guid.NewGuid();
var expectedOrderToAdd = new OrderToAdd()
{
Name = "Neil", ContactPhoneNumber = "01234"
};
var expectedCustomerId = Guid.NewGuid();
var phoneNumber = new PhoneNumber("07930123456");
var sut = new MobileWhenNewBuilder(dateTimeCreatorMock.Object, expectedGuid, expectedCustomerId, phoneNumber)
.AddInProgressOrder(expectedOrderToAdd, expectedInProgressOrderGuid);
var actual = sut.Build();
actual.State.Should().Be(Mobile.MobileState.New);
actual.Id.Should().Be(expectedId);
actual.GlobalId.Should().Be(expectedGuid);
actual.CustomerId.Should().Be(expectedCustomerId);
actual.InProgressOrder.GlobalId.Should().Be(expectedInProgressOrderGuid);
actual.InProgressOrder.Name.Should().Be(expectedOrderToAdd.Name);
actual.InProgressOrder.ContactPhoneNumber.Should().Be(expectedOrderToAdd.ContactPhoneNumber);
}
public CreateShould()
{
expectedOrderToAdd = new OrderToAdd()
{
Reference = Guid.NewGuid()
};
dataStoreMock = new Mock <IDataStore>();
sut = new OrdersController(dataStoreMock.Object);
}
public void ReturnOk()
{
var expectedOrder = new OrderToAdd
{
Reference = Guid.NewGuid()
};
var actual = sut.Create(expectedOrder);
actual.Should().BeOfType <OkResult>();
}
public void AddOrder()
{
var expectedOrder = new OrderToAdd
{
Reference = Guid.NewGuid()
};
sut.Create(expectedOrder);
ordersDataStoreMock.Verify(x => x.Add(It.Is <Order>(y => y.Reference == expectedOrder.Reference && y.Status == "New")));
transactionMock.Verify(x => x.Dispose());
}
public void AddMobileToRepositoryWithStateOfNew()
{
var expectedOrder = new OrderToAdd
{
Name = "Neil Armstrong",
ContactPhoneNumber = "01234 123123"
};
sut.Provision(expectedCustomer.GlobalId, expectedOrder);
mobileRepositoryMock.Verify(x => x.Add(It.Is <Mobile>(y =>
y.GlobalId == expectedNewMobileGlobalId &&
y.State == Mobile.MobileState.New &&
y.CustomerId == expectedCustomer.GlobalId)));
}
public MobileWhenNewBuilder AddInProgressOrder(OrderToAdd order, Guid orderGlobalId)
{
var newStateName = new EnumConverter().ToName <MobileState>(MobileState.New);
var dataEntity = new OrderDataEntity()
{
GlobalId = orderGlobalId,
Name = order.Name,
ContactPhoneNumber = order.ContactPhoneNumber,
State = newStateName,
Type = this.enumConverter.ToName <Order.OrderType>(Order.OrderType.Provision)
};
orders.Add(new Order(dataEntity));
return(this);
}
public IActionResult Create([FromBody] OrderToAdd orderToAdd)
{
var order = new Order
{
PhoneNumber = orderToAdd.PhoneNumber,
Name = orderToAdd.Name,
Reference = orderToAdd.Reference,
Status = "New"
};
using (ordersDataStore.BeginTransaction())
{
ordersDataStore.Add(order);
}
return(new OkResult());
}
public IActionResult Create([FromBody] OrderToAdd orderToAdd)
{
var order = new Order
{
PhoneNumber = orderToAdd.PhoneNumber,
Reference = orderToAdd.Reference,
Type = OrderTypes.Activate.ToString(),
Status = "New",
ActivationCode = orderToAdd.ActivationCode
};
using (dataStore.BeginTransaction())
{
dataStore.Add(order);
}
return(new OkResult());
}
public Mobile Provision(Guid id, OrderToAdd orderToAdd)
{
var customer = customerRepository.GetById(id);
if (customer == null)
{
logger.LogWarning("Attempt to Provision for an unknown Customer - CustomerId: {CustomerId}", id);
return(null);
}
var mobile = new MobileWhenNewBuilder(dateTimeCreator, guidCreator.Create(), id,
new PhoneNumber(orderToAdd.PhoneNumber))
.AddInProgressOrder(orderToAdd, guidCreator.Create())
.Build();
mobileRepository.Add(mobile);
return(mobile);
}
public IActionResult Provision(Guid id, [FromBody] OrderToAdd orderToAdd)
{
var mobile = customersService.Provision(id, orderToAdd);
if (mobile == null)
{
return(NotFound());
}
monitoring.Provision();
return(new OkObjectResult(new MobileResource
{
Id = mobile.Id,
GlobalId = mobile.GlobalId,
CustomerId = mobile.CustomerId,
CreatedAt = mobile.CreatedAt,
UpdatedAt = mobile.UpdatedAt
}));
}
public async Task <IActionResult> Create([FromBody, CustomizeValidator] OrderToAdd order, CancellationToken cancellationToken = default)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var isEmailConf = await _userService.IsEmailConfirmedAsync(HttpContext.User.Claims.Single(_ => _.Type == "id").Value);
if (isEmailConf.IsSuccess)
{
var result = await _orderService.AddAsync(order, HttpContext.User.Claims.Single(_ => _.Type == "id").Value, cancellationToken);
if (result.IsError)
{
throw new InvalidOperationException(result.Message);
}
await _notificationHubContext.Clients.All.SendAsync("New order!", cancellationToken);
return((IActionResult)Ok(result.Data));
//return result.IsError ? throw new InvalidOperationException(result.Message) : (IActionResult)Ok(result.Data);
}
else
{
return(StatusCode(StatusCodes.Status403Forbidden));
}
}
catch (InvalidOperationException ex)
{
Log.Error(ex, ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError, new CustumResult()
{
Status = StatusCodes.Status500InternalServerError, Message = ex.Message
}));
}
}
// /api/user/AddOrder
public async Task <OrderToReturn> AddOrder([FromBody] OrderToAdd order)
{
return(await _service.AddOrder(order, GetCurrentUrl(), User.GetUserId()));
}
//add row for order, rows for order details and row for credit card.
private bool addOrderDetails()
{
bool returnValue = true;
int orderCode = 0;
ItemStockTable itemStockT = new ItemStockTable();
ItemsTable itemT = new ItemsTable();
OrderDetailsTable orderDetailsT = new OrderDetailsTable();
//add order
try
{
OrdersTable ordersTable = new OrdersTable();
DataRow rowToAdd = ordersTable.Dt.NewRow();
DataRow currentRow = OrderToAdd.BuildRow();
orderCode = int.Parse(currentRow["CodeOrder"].ToString());
rowToAdd["CodeOrder"] = currentRow["CodeOrder"];
rowToAdd["IDCust"] = currentRow["IDCust"];
rowToAdd["DateOrder"] = currentRow["DateOrder"];
returnValue = ordersTable.Add(rowToAdd);
}
catch (Exception)
{
returnValue = false;
}
//add order details
OrderDetails detailToAdd;
groupItemsList();
foreach (var item in ShoppingCartListItems)
{
if (item.ItemAmount > 0)
{
detailToAdd = new OrderDetails();
detailToAdd.CodeOrder = orderCode;
detailToAdd.CodeItemStoke = itemStockT.getItemStockCode(item.ItemCode, item.ColorCode, item.SizeCode) + "";
//decrease amount of items in stock
returnValue = decreaseAmountOfItemInStock(int.Parse(detailToAdd.CodeItemStoke), item.ItemAmount);
detailToAdd.Amount = item.ItemAmount;
detailToAdd.PriceItem = itemT.getItemPrice(item.ItemCode);
detailToAdd.SaleItem = itemT.isSaleItem(item.ItemCode);
try
{
DataRow rowToAdd = detailToAdd.BuildRow();
returnValue = orderDetailsT.Add(rowToAdd);
}
catch (Exception)
{
returnValue = false;
}
}
}
//add credit card details
CreditCardOfCustomers card = new CreditCardOfCustomers();
CreditCardOfCustomersTable creditCardT = new CreditCardOfCustomersTable();
card.CodeCreditCard = creditCardT.getNextCode();
card.CodeOrder = orderCode;
card.NumCreditCard = txtNumCard.Text;
card.ValidityOfCreditCard = dtpValidate.Value;
card.IdOwner = txtBID.Text;
card.ThreeNumOnCard = int.Parse(txtBThree.Text);
card.TotalOfPrice = lblPaymentSum.Text;
card.NumOfPayments = (int)nudNumOfPayments.Value;
card.KindOfDeal = "חיוב";
DataRow rowToAddToCreditCardT = card.BuildRow();
try
{
creditCardT.Add(rowToAddToCreditCardT);
}
catch (Exception)
{
returnValue = false;
}
return(returnValue);
}
public async Task <Result <OrderView> > AddAsync(OrderToAdd order, string userIdFromIdentity, CancellationToken cancellationToken = default)
{
AppUser userIdentity = await _userManager.FindByIdAsync(userIdFromIdentity);
UserDB userDB = await _context.Users.Where(_ => _.IdFromIdentity == userIdentity.Id).Select(_ => _).AsNoTracking().FirstOrDefaultAsync(cancellationToken);
if (userDB is null || userIdentity is null)
{
return(Result <OrderView> .Fail <OrderView>(ExceptionConstants.USER_WAS_NOT_FOUND));
}
OrderDB orderToAdd = _mapper.Map <OrderDB>(order);
if (orderToAdd.IsInfoFromProfile)
{
if (userIdentity.Address is null || userIdentity.PhoneNumber is null || userIdentity.Name is null || userIdentity.Surname is null)
{
return(Result <OrderView> .Quite <OrderView>(NotificationConstans.FILL_PROFILE));
}
orderToAdd.Address = userIdentity.Address;
orderToAdd.PhoneNumber = userIdentity.PhoneNumber;
orderToAdd.Name = userIdentity.Name;
orderToAdd.Surname = userIdentity.Surname;
}
orderToAdd.PersonalDiscount = userIdentity.PersonalDiscount;
orderToAdd.UserId = userDB.Id;
orderToAdd.Status = Enum.GetName(typeof(OrderStatuses), 0);
orderToAdd.UpdateTime = DateTime.Now;
orderToAdd.TotalCost = 0;
orderToAdd.DeliveryCost = 0;
var connections = await _context.BasketDishes.Where(_ => _.BasketId == userDB.BasketId).Select(_ => _).AsNoTracking().ToListAsync(cancellationToken);
foreach (var connection in connections)
{
orderToAdd.TotalCost = orderToAdd.TotalCost.Value + connection.DishPrice.Value * (1 - (connection.Sale.Value / 100)) * connection.Quantity.Value;
}
orderToAdd.TotalCost *= 1 - userIdentity.PersonalDiscount / 100;
orderToAdd.TotalCost = Math.Round(orderToAdd.TotalCost.Value, 2);
if (orderToAdd.TotalCost < NumberСonstants.FREE_DELIVERY_BORDER)
{
orderToAdd.DeliveryCost = NumberСonstants.DELIVERY_PRICE;
}
_context.Orders.Add(orderToAdd);
foreach (var connection in connections)
{
connection.OrderId = orderToAdd.Id;
connection.BasketId = Guid.Empty;
_context.Entry(connection).Property(c => c.OrderId).IsModified = true;
_context.Entry(connection).Property(c => c.BasketId).IsModified = true;
}
try
{
await _context.SaveChangesAsync();
OrderDB orderAfterAdding = await _context.Orders.Where(_ => _.Id == orderToAdd.Id).Select(_ => _).AsNoTracking().FirstOrDefaultAsync(cancellationToken);
var dishList = await _context.BasketDishes.Where(_ => _.OrderId == orderAfterAdding.Id).AsNoTracking().ToListAsync(cancellationToken);
OrderView view = CollectOrderView(orderAfterAdding).Result.Data;
var users = await _userManager.GetUsersInRoleAsync(AppIdentityConstants.ADMIN);
foreach (var user in users)
{
var sendEmailBefore = await _emailSender.SendEmailAsync(user.Email, EmailConstants.NEW_ORDER_SUBJECT, EmailConstants.NEW_ORDER_MESSAGE, cancellationToken);
}
return(Result <OrderView> .Ok(view));
}
catch (DbUpdateConcurrencyException ex)
{
return(Result <OrderView> .Fail <OrderView>(ExceptionConstants.CANNOT_SAVE_MODEL + ex.Message));
}
catch (DbUpdateException ex)
{
return(Result <OrderView> .Fail <OrderView>(ExceptionConstants.CANNOT_SAVE_MODEL + ex.Message));
}
catch (ArgumentNullException ex)
{
return(Result <OrderView> .Fail <OrderView>(ExceptionConstants.SOURCE_IS_NULL + ex.Message));
}
}
