public async Task Consume(ConsumeContext <StockRequest> context)
{
var stockCode = context.Message.StockCode;
var stockResponse = new StockResponse
{
Success = true,
ConnectionId = context.Message.ConnectionId,
StockCode = stockCode,
};
StockDto stock = null;
try
{
stock = await _stockService.GetStock(stockCode);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
stockResponse.Success = false;
}
stockResponse.Stock = stock;
//
await context.Publish(stockResponse);
_logger.LogInformation("Stock request recieved {0}", stockCode);
}
public string GetJSONStock(int day)
{
StockResponse resp = new StockResponse(this.ReturnMilkStock(), this.ReturnSkinStock());
string json = new JavaScriptSerializer().Serialize(resp);
return(json);
}
private async Task <StockResponse> ReturnMockData()
{
await _logger.WarningAsync("BackendStockService: External call skipped, mocking response.");
StockResponse stockResponse = new StockResponse();
stockResponse.ProductStocks = new List <ProductStock>();
ShopAbc shopAbc = _shopAbcRepository.Table
.Where(s => s.AbcId == "1")
.Select(s => s).FirstOrDefault();
var urlRecords = await _urlRecordService.GetAllUrlRecordsAsync();
var shopUrl = urlRecords.Where(u => u.EntityName == "Shop" && u.EntityId == shopAbc.ShopId)
.Select(u => u.Slug)
.FirstOrDefault();
ProductStock mockShop = new ProductStock()
{
Shop = await _shopService.GetShopByIdAsync(shopAbc.ShopId),
ShopUrl = shopUrl,
Available = true,
Quantity = 1
};
stockResponse.ProductStocks.Add(mockShop);
return(stockResponse);
}
public StockResponse DeleteStock(string stockId)
{
var response = new StockResponse {
Acknowledge = AcknowledgeType.Success
};
try
{
var stockEntity = StockDao.GetStock(stockId);
response.Message = StockDao.DeleteStock(stockEntity);
if (!string.IsNullOrEmpty(response.Message))
{
response.Acknowledge = AcknowledgeType.Failure;
if (response.Message.Contains("FK_INInwardOutwardDetail_Stock"))
{
response.Message = string.Format("Bạn không thể xóa kho {0} vì đã có phát sinh trong chứng từ nhập kho/xuất kho", stockEntity.StockCode);
return(response);
}
return(response);
}
response.StockId = stockEntity.StockId;
return(response);
}
catch (Exception ex)
{
response.Acknowledge = AcknowledgeType.Failure;
response.Message = ex.Message;
return(response);
}
}
private object GetJSONStock(int forDay, decimal milkQ, int skinsQ)
{
StockResponse resp = new StockResponse(this.ReturnMilkStock(), this.ReturnSkinStock(), milkQ, skinsQ);
string json = new JavaScriptSerializer().Serialize(resp);
return(json);
}
private async void CallRoute(Company company, DateTime date)
{
CheckLoading(1);
String startDate = Utils.GetFormattedDate(date);
HttpClient client = new HttpClient();
try {
HttpResponseMessage message = await client.GetAsync(Utils.GetUrl(company.symbol, startDate));
String mes = await message.Content.ReadAsStringAsync();
StockResponse res = Newtonsoft.Json.JsonConvert.DeserializeObject <StockResponse>(mes);
company.closeStockValues.Clear();
company.tradingDays.Clear();
for (int i = 0; i < res.results.Count; i++)
{
Result r = res.results[i];
company.closeStockValues.Add(r.close);
company.tradingDays.Add(DateTime.ParseExact(r.tradingDay, "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture));
}
CheckLoading(-1);
} catch (Exception e) {
Utils.Print(e.Message);
CheckLoading(-1);
}
}
public StockResponse PedidoDeStockPorSucursal(int idSucursal)
{
var wsDAL = new WebserviceDAL();
var result = wsDAL.ObtenerStockPorSucursal(idSucursal);
var stockResponse = new StockResponse()
{
ProductosARenovar = new List <BebidasBE>(),
ProductosEnStock = new List <BebidasBE>()
};
result.ForEach(bebida =>
{
if (bebida.StockActual < bebida.StockMinimo)
{
stockResponse.ProductosARenovar.Add(bebida);
}
else
{
stockResponse.ProductosEnStock.Add(bebida);
}
});
return(stockResponse);
}
public async Task <IActionResult> CreateAsync(CreateViewModel viewModel)
{
if (!ModelState.IsValid)
{
ViewData["ErrorMessage"] = "Invalid form submission.";
return(PartialView("_CreateStock", viewModel));
}
Guid _UserID = GetLoggedUserID();
if (_UserID == Guid.Empty)
{
return(Json(new { error = $"{GlobalConstants.ERROR_ACTION_PREFIX} retrieve user details to create {ENTITY_NAME}" }));
}
StockResponse _Response = await __StockManager.CreateAsync(viewModel.ToRequest(_UserID));
if (!_Response.Success)
{
ViewData["ErrorMessage"] = _Response.ErrorMessage;
return(PartialView("_CreateStock", new CreateViewModel()));
}
return(Json(new { success = $"{GlobalConstants.SUCCESS_ACTION_PREFIX} created {ENTITY_NAME}" }));
}
public void Mapper_ToStockContract_ReturnsStockResponse()
{
// Arrange
string currentTime = System.DateTime.Now.ToString();
var item = new StockDB();
item.Name = "SendStockTest";
item.Price = 123.45f;
item.LastUpdated = currentTime;
var mapper = new Mapper();
StockResponse expectedResponse = new StockResponse
{
Name = "SendStockTest",
Price = 123.45f,
LastUpdated = currentTime
};
StockResponse result;
// Act
result = mapper.ToStockContract(item);
// Assert
Assert.AreEqual(expectedResponse.Name, result.Name);
Assert.AreEqual(expectedResponse.Price, result.Price);
Assert.AreEqual(expectedResponse.LastUpdated, result.LastUpdated);
}
private void SerializeStock(StockResponse result)
{
XmlSerializer writer = new XmlSerializer(typeof(BebidasBE[]));
var path = Path.Combine(Server.MapPath("~/Security"), "stock.xml");
FileStream file = File.Create(path);
writer.Serialize(file, result.ProductosEnStock);
file.Close();
}
public static StockResponse ToStockResponse(this StockModel stockModel)
{
if (stockModel == null)
{
return(null);
}
var stockResponse = new StockResponse(stockModel.Id, stockModel.ProductId, stockModel.ProductCode, stockModel.AvailableStock, stockModel.StockActionId, stockModel.LastStockOperationDate);
return(stockResponse);
}
internal static EditViewModel ToEditViewModel(this StockResponse response)
{
return(response == null ? null : new EditViewModel
{
Description = response.Description,
Name = response.Name,
Quantity = response.Quantity,
StockType = response.StockType,
StockUID = response.UID
});
}
public async Task <StockResponse> GetStock(string stockCode, string url, string stockToken, HttpMethod httpMethod, bool sendMessage, IMessageController msgController, string userEmail)
{
StockResponse result = new StockResponse();
result.StockCode = stockCode;
try
{
string stockUrl = url.Replace(stockToken, stockCode);
var request = new HttpRequestMessage(httpMethod, stockUrl);
var httpClient = new HttpClient();
var response = await httpClient.SendAsync(request);
if (response.IsSuccessStatusCode)
{
var data = await response.Content.ReadAsStreamAsync();
ReadStock(data, ref result);
}
else
{
result.StockValue = string.Empty;
result.Error = new Exception(string.Format("Error while trying to call {0} returned status code {1}", stockUrl, response.StatusCode));
}
}
catch (Exception ex)
{
result.StockValue = string.Empty;
result.Error = ex;
}
if (sendMessage)
{
ChatMessage msg = new ChatMessage();
msg.UserEmail = "ChatBot";
msg.IsChatBotMessage = true;
if (result.StockValue != string.Empty)
{
msg.MessageText = string.Format("{0} quote is ${1} per share", stockCode, result.StockValue);
await msgController.SendMessage(msg);
}
else
{
msg.MessageText = string.Format("Sorry {0}, I could not retrieve the quote share for {1}", userEmail, stockCode);
if (result.Error != null)
{
msg.MessageText += string.Format(", reason: {0}", result.Error.Message);
}
await msgController.SendErrorMessage(msg);
}
}
return(result);
}
internal static StockViewModel ToViewModel(this StockResponse response)
{
return(response == null ? null : new StockViewModel
{
UID = response.UID,
Name = response.Name,
Description = response.Description,
Quantity = response.Quantity,
StockType = response.StockType,
AmendedTimestamp = response.AmendedTimestamp
});
}
internal static DeleteViewModel ToDeleteViewModel(this StockResponse response)
{
return(response == null ? null : new DeleteViewModel
{
AmendedTimestamp = response.AmendedTimestamp,
Description = response.Description,
Name = response.Name,
Quantity = response.Quantity,
StockType = response.StockType,
UID = response.UID
});
}
public static string GetStockQuoteFormatted(this StockResponse stock)
{
if (!stock.Succeeded)
{
return($"Cannot fetch information for {stock.Symbol}");
}
else if (string.IsNullOrWhiteSpace(stock.Close) || stock.Close.Equals("N/D"))
{
return($"{stock.Symbol} quote is not recognized");
}
return($"{stock.Symbol} quote is { stock.Close} per share");
}
public async Task <IActionResult> DisplayClearanceStock(int productId)
{
StockResponse stockResponse = await _backendStockService.GetApiStockAsync(productId);
if (stockResponse != null)
{
stockResponse.ProductStocks = stockResponse.ProductStocks
.Where(ps => ps.Quantity > 0)
.Select(ps => ps).ToList();
}
return(PartialView("~/Plugins/Widgets.AbcPickupInStore/Views/_ClearanceStoreStock.cshtml", stockResponse));
}
public static StockHttpResponse ToStockHttpResponse(this StockResponse stockResponse)
{
return(stockResponse == null
? null
: new StockHttpResponse
{
StockId = stockResponse.StockId,
ProductId = stockResponse.ProductId,
ProductCode = stockResponse.ProductCode,
AvailableStock = stockResponse.AvailableStock,
LastStockOperationDate = stockResponse.LastStockOperationDate
});
}
internal static StockEntity ToEntity(this StockResponse response)
{
return(response == null ? null : new StockEntity
{
UID = response.UID,
Name = response.Name,
Description = response.Description,
Quantity = response.Quantity,
StockType = response.StockType,
CreatedTimestamp = response.CreatedTimestamp,
AmendedTimestamp = response.AmendedTimestamp
});
}
public async Task <IActionResult> StoreSelected(string shopId)
{
Shop shop = await _shopService.GetShopByIdAsync(Int32.Parse(shopId));
_customerShopService.InsertOrUpdateCustomerShop((await _workContext.GetCurrentCustomerAsync()).Id, Int32.Parse(shopId));
var shoppingCartItems = (await _shoppingCartService.GetShoppingCartAsync(await _workContext.GetCurrentCustomerAsync(), ShoppingCartType.ShoppingCart))
.Select(sci => sci);
// update all attribute definitions
foreach (var cartItem in shoppingCartItems)
{
// update attribute definitions to include the proper name
ProductAttributeMapping pickupAttribute = await _attributeUtilities.GetPickupAttributeMappingAsync(cartItem.AttributesXml);
if (pickupAttribute != null)
{
// check if product is available at the selected store
StockResponse stockResponse = await _backendStockService.GetApiStockAsync(cartItem.ProductId);
bool available = false;
if (stockResponse != null)
{
available = stockResponse.ProductStocks.Where(ps => ps.Available && ps.Shop.Id == shop.Id).Any();
}
if (available)
{
string removedAttr = _productAttributeParser.RemoveProductAttribute(cartItem.AttributesXml, pickupAttribute);
cartItem.AttributesXml = await _attributeUtilities.InsertPickupAttributeAsync(
await _productService.GetProductByIdAsync(cartItem.ProductId),
stockResponse,
removedAttr);
}
else
{
cartItem.AttributesXml = await _attributeUtilities.InsertHomeDeliveryAttributeAsync(
await _productService.GetProductByIdAsync(cartItem.ProductId),
cartItem.AttributesXml);
}
await _shoppingCartService.UpdateShoppingCartItemAsync(await _workContext.GetCurrentCustomerAsync(), cartItem.Id,
cartItem.AttributesXml, cartItem.CustomerEnteredPrice, null, null, cartItem.Quantity, false);
}
}
return(Json(await _shopService.GetShopByIdAsync(int.Parse(shopId))));
}
public void DeserializeStockResponse()
{
var serializer = new RestClientSerializer();
var id = Guid.NewGuid();
var json = "{\"id\":\"" + id + "\","
+ "\"asxCode\":\"ABC\","
+ "\"name\":\"ABC Pty Ltd\","
+ "\"category\":\"australianStocks\","
+ "\"trust\":true,"
+ "\"stapledSecurity\":true,"
+ "\"listingDate\":\"2000-01-01\","
+ "\"delistedDate\":\"9999-12-31\","
+ "\"lastPrice\":12.00,"
+ "\"companyTaxRate\":0.30,"
+ "\"dividendRoundingRule\":\"round\","
+ "\"drpActive\":true,"
+ "\"drpMethod\":\"roundDown\","
+ "\"childSecurities\":["
+ "{\"asxCode\":\"ABC1\",\"name\":\"Child\",\"trust\":true}"
+ "]}";
var command = serializer.Deserialize <StockResponse>(json);
var expected = new StockResponse()
{
Id = id,
AsxCode = "ABC",
Name = "ABC Pty Ltd",
Category = AssetCategory.AustralianStocks,
Trust = true,
StapledSecurity = true,
ListingDate = new Date(2000, 01, 01),
DelistedDate = Date.MaxValue,
LastPrice = 12.00m,
CompanyTaxRate = 0.30m,
DividendRoundingRule = RoundingRule.Round,
DrpActive = true,
DrpMethod = DrpMethod.RoundDown
};
expected.AddChild("ABC1", "Child", true);
command.Should().BeEquivalentTo(expected);
}
public async Task <IActionResult> DeleteModal(Guid stockUID)
{
Guid _UserID = GetLoggedUserID();
if (_UserID == Guid.Empty)
{
return(RedirectToAction("Index", "Stock", new { Area = "Stock", errorMessage = $"{GlobalConstants.ERROR_ACTION_PREFIX} retrieve user details to delete {ENTITY_NAME}" }));
}
StockResponse _Response = await __StockManager.GetAsync(new UIDRequest { UID = stockUID });
if (!_Response.Success)
{
return(RedirectToAction("Index", "Stock", new { Area = "Stock", errorMessage = _Response.ErrorMessage }));
}
return(PartialView("_DeleteStock", _Response.ToDeleteViewModel()));
}
public async Task <bool> AvailableAtStore(int shopId, int productId)
{
string backendId = _shopAbcRepository.Table
.Where(sabc => sabc.ShopId == shopId)
.Select(sabc => sabc.AbcId).FirstOrDefault();
StockResponse response = await GetApiStockAsync(productId);
if (response != null)
{
bool availableAtStore = response.ProductStocks
.Where(ps => ps.BranchId == backendId)
.Select(ps => ps.Available).FirstOrDefault();
return(availableAtStore);
}
return(false);
}
public StockResponse InsertStock(StockEntity stockEntity)
{
var response = new StockResponse {
Acknowledge = AcknowledgeType.Success
};
try
{
if (!stockEntity.Validate())
{
foreach (string error in stockEntity.ValidationErrors)
{
response.Message += error + Environment.NewLine;
}
response.Acknowledge = AcknowledgeType.Failure;
return(response);
}
stockEntity.StockId = Guid.NewGuid().ToString();
//check ma trung
var stockEntityExited = StockDao.GetStocksByStockCode(stockEntity.StockCode);
if (stockEntityExited != null)
{
response.Acknowledge = AcknowledgeType.Failure;
response.Message = string.Format(@"Mã kho {0} đã tồn tại trong hệ thống. Vui lòng nhập mã khác", stockEntityExited.StockCode);
return(response);
}
response.Message = StockDao.InsertStock(stockEntity);
if (!string.IsNullOrEmpty(response.Message))
{
response.Acknowledge = AcknowledgeType.Failure;
return(response);
}
response.StockId = stockEntity.StockId;
return(response);
}
catch (Exception ex)
{
response.Acknowledge = AcknowledgeType.Failure;
response.Message = ex.Message;
return(response);
}
}
public async Task <StockResponse> GetAsync(UIDRequest request)
{
StockResponse _Response = new StockResponse();
if (request.UID == Guid.Empty)
{
_Response.Success = false;
_Response.ErrorMessage = $"{GlobalConstants.ERROR_ACTION_PREFIX} retrieve {ENTITY_NAME}.";
}
StockEntity _StockEntity = await __StockRepository.GetAsync(request.UID);
if (_StockEntity == null)
{
_Response.Success = false;
_Response.ErrorMessage = $"{GlobalConstants.ERROR_ACTION_PREFIX} retrieve {ENTITY_NAME}.";
}
return(_StockEntity.ToResponse() ?? _Response);
}
/// <summary>
/// Getses the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>StockResponse.</returns>
public StockResponse Gets(StockRequest request)
{
var response = new StockResponse();
if (request.LoadOptions.Contains("Stocks"))
{
if (request.LoadOptions.Contains("IsActive"))
{
response.Stocks = StockDao.GetStocksByActive(true);
}
else
{
response.Stocks = StockDao.GetStocks();
}
}
if (request.LoadOptions.Contains("Stock"))
{
response.Stock = StockDao.GetStock(request.StockId);
}
return(response);
}
public async Task <IActionResult> FilterClosestStores(double lat, double lng, int productId)
{
StockResponse stockResponse = await _backendStockService.GetApiStockAsync(productId);
if (stockResponse != null)
{
stockResponse.ProductStocks = stockResponse.ProductStocks
.Select(s => s)
.OrderBy(s => Distance(Double.Parse(s.Shop.Latitude), Double.Parse(s.Shop.Longitude), lat, lng))
.Take(5).ToList();
}
else
{
stockResponse = new StockResponse
{
ProductStocks = new List <ProductStock>(),
ProductId = productId
};
}
return(PartialView("~/Plugins/Widgets.AbcPickupInStore/Views/SelectStoreForPickup.cshtml", stockResponse));
}
public async Task <string> InsertPickupAttributeAsync(
Product product,
StockResponse stockResponse,
string attributes,
Shop customerShop = null
)
{
Shop shop = customerShop ?? await GetCustomerShop();
string shopName = shop != null ? shop.Name : "Select Store";
ProductAttribute pickupAttribute = await GetPickupAttributeAsync();
// current product potential attribute mappings
var pams =
await _productAttributeService.GetProductAttributeMappingsByProductIdAsync(product.Id);
var pickupAttributeMapping = pams
.Where(pam => pam.ProductAttributeId == pickupAttribute.Id)
.Select(pam => pam).FirstOrDefault();
if (pickupAttributeMapping != null)
{
string pickupMsg = stockResponse.ProductStocks
.Where(ps => ps.Shop.Id == shop.Id)
.Select(ps => ps.Message).FirstOrDefault();
attributes = _productAttributeParser.AddProductAttribute(attributes, pickupAttributeMapping, shop.Name + "\nAvailable: " + pickupMsg);
// remove home delivery attributes
var homeDeliveryAttributeMapping = await GetHomeDeliveryAttributeMappingAsync(attributes);
if (homeDeliveryAttributeMapping != null)
{
attributes = _productAttributeParser.RemoveProductAttribute(attributes, homeDeliveryAttributeMapping);
}
}
return(attributes);
}
public async Task GetByIdAtDate()
{
var mockRepository = new MockRepository(MockBehavior.Strict);
var stock = new StockResponse()
{
Id = Guid.NewGuid(), AsxCode = "ABC"
};
var messageHandler = mockRepository.Create <IRestClientMessageHandler>();
messageHandler.Setup(x => x.GetAsync <StockResponse>(It.Is <string>(x => x == "stocks/" + stock.Id + "?date=2000-01-02")))
.Returns(Task <StockResponse> .FromResult(stock))
.Verifiable();
var resource = new StockResource(messageHandler.Object);
var result = await resource.Get(stock.Id, new Date(2000, 01, 02));
result.Should().BeEquivalentTo(stock);
mockRepository.Verify();
}
private async Task SyncAvailableStock(long productId, long stockActionId, int availableStock)
{
await _distributedLockManager.LockAsync(UpdateAvailableStockLockKey(productId),
async() =>
{
var queryStockCommand = new QueryStockCommand(0, 1)
{
ProductId = productId
};
StockCollectionResponse stockCollectionResponse = await _mediator.Send(queryStockCommand);
StockResponse stockResponse = stockCollectionResponse.Data.First();
var updateAvailableStockCommand = new UpdateAvailableStockCommand(stockResponse.StockId, availableStock, stockActionId, stockResponse.LastStockOperationDate);
try
{
await _mediator.Send(updateAvailableStockCommand);
}
catch (StockTimeLineException e)
{
_logger.LogInformation(e.Message);
}
});
}
public string GetJSONStock(int day)
{
StockResponse resp = new StockResponse(this.ReturnMilkStock(), this.ReturnSkinStock());
string json = new JavaScriptSerializer().Serialize(resp);
return json;
}
private object GetJSONStock(int forDay, decimal milkQ, int skinsQ)
{
StockResponse resp = new StockResponse(this.ReturnMilkStock(), this.ReturnSkinStock(), milkQ, skinsQ);
string json = new JavaScriptSerializer().Serialize(resp);
return json;
}
