public bool AddBasket(Basket basket)
{
var basketDto = new BasketDto();
basketDto = convert.ToBasketDto(basket);
var model = new bool();
using (var client = new ToteService.BetListServiceClient())
{
try
{
client.Open();
model = client.AddBasket(basketDto);
client.Close();
}
catch (FaultException <CustomException> customEx)
{
log.Error(customEx.Message);
return(false);
}
catch (CommunicationException commEx)
{
log.Error(commEx.Message);
return(false);
}
}
return(model);
}
public IBasket CreateBasket(IUser currentUser)
{
BasketDto dto = new BasketDto();
StormBasket stormBasket = new StormBasket();
stormBasket.Items = new List <StormBasketItem>();
string url = "ShoppingService.svc/rest/CreateBasket?ipAddress=127.0.0.1&createdBy=1";
if (!string.IsNullOrEmpty(currentUser.ExternalId))
{
stormBasket.CustomerId = Convert.ToInt32(currentUser.ExternalId);
}
if (currentUser.Company != null && !string.IsNullOrEmpty(currentUser.Company.ExternalId))
{
stormBasket.CompanyId = Convert.ToInt32(currentUser.Company.ExternalId);
}
stormBasket.CurrencyId = Convert.ToInt32(currentUser.CurrencyCode);
stormBasket = _stormConnectionManager.PostResult <StormBasket>(url, stormBasket);
dto.ExternalId = stormBasket.Id.ToString();
dto.Items = new List <IBasketItem>();
return(dto);
}
public bool AddBasket(BasketDto basketDto)
{
if (basketDto == null)
{
GenerateFaultException("AddBasket", "ArgumentException");
}
var parameters = new List <Parameter>();
parameters.Add(new Parameter {
Type = DbType.String, Name = "@UserId", Value = basketDto.UserId
});
parameters.Add(new Parameter {
Type = DbType.Int32, Name = "@MatchId", Value = basketDto.MatchId
});
parameters.Add(new Parameter {
Type = DbType.Int32, Name = "@EventId", Value = basketDto.EventId
});
var connection = new Connection <BasketDto>();
try
{
return(connection.GetConnectionUpdate(CommandType.StoredProcedure, "AddBasket", parameters));
}
catch (SqlException sqlEx)
{
var exception = new CustomException();
exception.Title = "AddBasket";
log.Error(sqlEx.Message);
throw new FaultException <CustomException>(exception, sqlEx.Message);
}
}
public async Task AddToBasketAsync(BasketDto basketDto)
{
var basketItems = new List <BasketDto>();
basketDto.CreatedOn = DateTime.Now;
basketItems.Add(basketDto);
var serializedbasketItems = await _daprClient.GetStateAsync <string>(
_cofiguration["DaprConfiguration:StateStore"],
_cofiguration["DaprConfiguration:StateStoreKey"]
);
if (!string.IsNullOrEmpty(serializedbasketItems))
{
var deserializedBasketItems = JsonConvert.DeserializeObject <IEnumerable <BasketDto> >(serializedbasketItems);
foreach (var item in deserializedBasketItems)
{
basketItems.Add(item);
}
}
var serializedBasket = JsonConvert.SerializeObject(basketItems);
await _daprClient.SaveStateAsync(
_cofiguration["DaprConfiguration:StateStore"],
_cofiguration["DaprConfiguration:StateStoreKey"],
serializedBasket
);
return;
}
public void GetEmptyBasket()
{
var basketDto = new BasketDto()
{
Id = 1,
User = new UserDto()
{
Id = ConstraintHelper.UserId,
},
IsActive = true,
Products = new List <BasketProductDto>()
{
}
};
var responseBasketDto = Task.FromResult(new ResponseDto <BasketDto, GetBasketReturnTypes>());
responseBasketDto.Result.Data = basketDto;
responseBasketDto.Result.IsSuccess = false;
responseBasketDto.Result.ResponseCode = GetBasketReturnTypes.Wrn_EmptyBasket;
ConstraintHelper.mockBasket.Setup(x => x.GetBasket(ConstraintHelper.UserId)).Returns(responseBasketDto);
var service = new BasketService(ConstraintHelper.mockBasketProduct.Object, ConstraintHelper.mockBasket.Object, ConstraintHelper.mockProductStock.Object, ConstraintHelper.mockUnitOfWork.Object, ConstraintHelper.mockLogger.Object);
var actual = service.GetBasket(ConstraintHelper.UserId);
Assert.AreEqual(GetBasketReturnTypes.Wrn_EmptyBasket, actual.Result.ResponseCode);
Assert.AreEqual(basketDto, actual.Result.Data);
}
public async Task <IActionResult> SaveOrUpdateBasket(BasketDto basketDto)
{
basketDto.UserId = _sharedIdentityService.GetUserId;
var response = await _basketService.SaveOrUpdate(basketDto);
return(CreateActionResultInstance(response));
}
public ActionResult OrderBasket()
{
var shopGuid = Session[SessionKeys.ClientSelectedShopGuid];
if (shopGuid == null)
{
return(View("~/Views/ClientCore/ShopNotFound.cshtml"));
}
Guid parsedShopGuid;
if (!Guid.TryParse(shopGuid.ToString(), out parsedShopGuid))
{
return(View("~/Views/ClientCore/ShopNotFound.cshtml"));
}
BasketDto basket = _basketRepositoryService.GetShopBasketForClient(parsedShopGuid, User.Identity.Name);
if (basket.Equals(BasketDto.EmptyBasket))
{
return(View("BasketNotFound"));
}
ServiceActionResult result = _orderService.FinalizeOrder(basket.BasketGuid);
if (result.Status == ActionStatus.Successfull)
{
return(View("OrderFinalized"));
}
return(View("UnexpectedError", result));
}
public async Task <ActionResult <Basket> > UpdateBasket(BasketDto basketDto)
{
var basket = _mapper.Map <BasketDto, Basket>(basketDto);
var updatedBasket = await _basketRepository.UpdateBasketAsync(basket);
return(Ok(updatedBasket));
}
public ActionResult ShopBasket()
{
if (Session[SessionKeys.ClientSelectedShopGuid] == null)
{
return(View("ShopNotFound"));
}
Guid parsedShopGuid;
if (!Guid.TryParse(Session[SessionKeys.ClientSelectedShopGuid].ToString(), out parsedShopGuid))
{
return(View("ShopNotFound"));
}
BasketDto basket = _basketRepository.GetShopBasketForClient(parsedShopGuid, User.Identity.Name);
if (basket.Equals(BasketDto.EmptyBasket))
{
return(View("BasketProductView", new BasketViewModel()));
}
if (basket.Products.IsNullOrEmpty())
{
View("BasketProductView", new BasketViewModel());
}
return(View("BasketProductView", new BasketViewModel()
{
Products = basket.Products.Select(p => p.Map())
}));
}
public BasketDto GetBasketById(int basketId, int userId)
{
var model = new BasketDto();
using (var client = new ToteService.BetListServiceClient())
{
try
{
client.Open();
model = client.GetBasketById(basketId, userId);
if (model == null)
{
throw new NullReferenceException();
}
client.Close();
}
catch (FaultException <CustomException> customEx)
{
log.Error(customEx.Message);
return(null);
}
catch (CommunicationException commEx)
{
log.Error(commEx.Message);
return(null);
}
catch (NullReferenceException nullEx)
{
log.Error(nullEx.Message);
return(null);
}
}
return(model);
}
public async Task <ActionResult <Basket> > SetBasket(BasketDto basketDto)
{
var basket = _mapper.Map <BasketDto, Basket>(basketDto);
var data = await _repo.SetBasket(basket);
return(Ok(data));
}
public async Task <ActionResult <BasketDto> > UpdateBasket(BasketDto basketDto)
{
var customerBasket = _mapper.Map <CustomerBasket>(basketDto);
var updatedBasket = await _basketRepo.UpdateBasketAsync(customerBasket);
return(_mapper.Map <BasketDto>(updatedBasket));
}
public void ConvertToDto_BasketNotNull_ReturnSameProducts()
{
Basket basket = MockBasket();
BasketDto basketDto = basket.ConvertToDto();
Assert.Equal(basketDto.ProductDefinitives, basket.Products);
}
public void ConvertToDto_BasketNotNull_ReturnSameCustomerEmail()
{
Basket basket = MockBasket();
BasketDto basketDto = basket.ConvertToDto();
Assert.Equal(basketDto.CustomerEmail, basket.CustomerEmail);
}
public void ConvertToDto_BasketNotNull_ReturnSameId()
{
Basket basket = MockBasket();
BasketDto basketDto = basket.ConvertToDto();
Assert.Equal(basketDto.Id, basket.Id);
}
public static BasketViewModel Map(this BasketDto basket)
{
Mapper.Initialize(m => m.CreateMap <BasketDto, BasketViewModel>()
.ForMember(b => b.Products, opts => opts.MapFrom(src => src.Products.Select(p => p.Map())))
.ForMember(b => b.OrderState, opts => opts.MapFrom(src => src.OrderState))
.ForMember(b => b.UpdateDateTime, opts => opts.MapFrom(src => src.UpdateDate)));
return(Mapper.Map <BasketViewModel>(basket));
}
private void PrintBasket(BasketDto basket)
{
Console.WriteLine($"Subtotal: £{basket.SubTotal}");
var discountText = string.IsNullOrEmpty(basket.DiscountText)
? "(No offers available)"
: $"{basket.DiscountText} : -{basket.DiscountAmount:0.00}";
Console.WriteLine($"{discountText}");
Console.WriteLine($"Total: £{basket.Total:0.00}");
}
public async Task <IActionResult> SaveOrUpdateBasket(BasketDto basketDto)
{
basketDto.UserId = _sharedIdentityService.GetUserId;
var response = await _basketService.SaveOrUpdate(basketDto);
if (response.IsSuccess)
{
return(Ok(response));
}
return(NotFound(response));
}
public Basket ToBasket(BasketDto basketDto)
{
var basket = new Basket
{
BasketId = basketDto.BasketId,
UserId = basketDto.UserId,
MatchId = basketDto.MatchId,
EventId = basketDto.EventId
};
return(basket);
}
public BasketDto ToBasketDto(Basket basket)
{
var basketDto = new BasketDto
{
BasketId = basket.BasketId,
UserId = basket.UserId,
Login = basket.Login,
MatchId = basket.MatchId,
EventId = basket.EventId
};
return(basketDto);
}
public void UpdateBasketsDtoToDb(BasketDto basketEditDto)
{
Basket _basketDbModel;
_basketDbModel = _dataManager.Baskets.GetBasketById(basketEditDto.Id);
_basketDbModel.CurrentUser = basketEditDto.CurrentUser;
_basketDbModel.Count = basketEditDto.Count;
_basketDbModel.isProcessed = basketEditDto.isProcessed;
_basketDbModel.BasketDishesId = basketEditDto.DishesId;
_dataManager.Baskets.UpdateBaskets(_basketDbModel);
}
public async Task <ActionResult> AddToBasketAsync([FromBody] BasketDto basketDto)
{
try
{
await _basketService.AddToBasketAsync(basketDto);
return(Created("Item added to basket.", basketDto));
}
catch (Exception ex)
{
return(BadRequest($"{ex.Message} \n {ex.InnerException.Message}"));
}
}
//public async Task<IResult> CheckBasket()
//{
// try
// {
// }
// catch (Exception)
// {
// throw;
// }
//}
public IDataResult <BasketDto> InsertProductsToBasket(List <ProductDto> productDtos)
{
try
{
ProductDtoInsertBasketBusinessOperation productDtoInsertBasketBusinessOperation = new ProductDtoInsertBasketBusinessOperation(productDtos);
BasketDto basketDto = productDtoInsertBasketBusinessOperation.Create();
return(new DataResult <BasketDto>(ResultStatus.Error, "Ürünler sepete eklendi", data: null));
}
catch (Exception)
{
throw;
}
}
public BasketDto GetBasket(GetBasketQuery msg)
{
BasketDto basketDto = null;
var uri = this.GenerateRequestUri($"{msg.CustomerId}");
var response = this.Get(uri, content: null);
if (response.IsSuccessStatusCode)
{
basketDto = response.Content.ReadAsAsync <BasketDto>().Result;
}
return(basketDto);
}
public BasketDto Create()
{
try
{
BasketDto basketDto = new BasketDto
{
Products = _productDtos
};
return(basketDto);
}
catch (Exception)
{
throw;
}
}
public async Task Save(Basket basket)
{
var dto = await _context.Baskets.Include(b => b.Lines)
.FirstOrDefaultAsync(b => b.Id == basket.Id.Value);
if (dto == null)
{
dto = new BasketDto(basket);
_context.Baskets.Add(dto);
}
else
{
dto.Lines = basket.Lines.Select(l => new BasketLineDto(l, dto)).ToList();
_context.Baskets.Update(dto);
}
}
public BasketDto ClearBasket(ClearBasketCommand msg)
{
BasketDto basketDto = null;
var uri = this.GenerateRequestUri($"{msg.CustomerId}");
var response = this.Put(uri, content: null);
if (response.IsSuccessStatusCode)
{
basketDto = this.GetBasket(new GetBasketQuery {
CustomerId = msg.CustomerId
});
}
return(basketDto);
}
public BasketDto AddItemToBasket(AddItemToBasketCommand msg)
{
BasketDto basketDto = null;
var uri = this.GenerateRequestUri($"{msg.CustomerId}", "item");
var response = this.Post(uri, new { productId = msg.ProductId, quantity = msg.Quantity });
if (response.IsSuccessStatusCode)
{
basketDto = this.GetBasket(new GetBasketQuery {
CustomerId = msg.CustomerId
});
}
return(basketDto);
}
public BasketDto RemoveItemFromBasket(RemoveItemFromBasketCommand msg)
{
BasketDto basketDto = null;
var uri = this.GenerateRequestUri($"{msg.CustomerId}", "item");
var response = this.Delete(uri, new { productId = msg.ProductId });
if (response.IsSuccessStatusCode)
{
basketDto = this.GetBasket(new GetBasketQuery {
CustomerId = msg.CustomerId
});
}
return(basketDto);
}
public BasketDto ChangeItemQuantity(ChangeBasketItemQuantityCommand msg)
{
BasketDto basketDto = null;
var uri = this.GenerateRequestUri($"{msg.CustomerId}", "item");
var response = this.Put(uri, new { productId = msg.ProductId, newQuantity = msg.NewQuantity });
if (response.IsSuccessStatusCode)
{
basketDto = this.GetBasket(new GetBasketQuery {
CustomerId = msg.CustomerId
});
}
return(basketDto);
}
