public async Task A_Transaction_Will_Not_Be_Created_If_The_Price_Is_High()
{
var client = _factory.CreateDefaultClient();
var createdAccountDetails = await CreateAccount(client);
var requestData = new BuyRequest()
{
AccountNumber = createdAccountDetails.AccountNumber,
MaxUnitPrice = 50,
ProductCode = Constants.ProductA,
Quantity = 10
};
var response = await client.PostAsJsonAsync("/api/Purchases", requestData);
response.EnsureSuccessStatusCode();
var responseData = await response.Content.ReadAsJsonAsync <Purchase>();
Assert.False(responseData.Success);
Assert.Equal(Constants.ProductA, responseData.ProductCode);
Assert.Equal(0, responseData.Quantity);
Assert.True(responseData.UnitPrice > requestData.MaxUnitPrice);
Assert.Equal(0, responseData.TotalValue);
Assert.Equal(Guid.Empty, responseData.TransactionID);
}
private void ButtonBuy_Click(object sender, RoutedEventArgs e)
{
myLogger.Info("Buy button was pressed");
string c = commodity.Text;
string a = amount.Text;
string p = price.Text;
if (c.Length != 0 & a.Length != 0 & p.Length != 0)
{
int cI = Convert.ToInt32(c);
int aI = Convert.ToInt32(a);
int pI = Convert.ToInt32(p);
BuyRequest SB = new BuyRequest();
int output = SB.sendBuyRequest(pI, cI, aI);
if (output == -1)
{
MessageBox.Show("Failed:");
}
else
{
MessageBox.Show("The Buy is Done:request id:" + output);
EnterHistory("Buy", cI, aI, pI, output, false);
}
}
else
{
MessageBox.Show("full all the fields");
}
commodity.Text = "";
amount.Text = "";
price.Text = "";
}
public IActionResult BuyDefault(BuyRequest buyRequest)
{
if (Application.Resolve <ICoreService>().Config.ReadOnlyMode)
{
return(new BadRequestResult());
}
if (!string.IsNullOrWhiteSpace(buyRequest.Pair))
{
ISignalsService signalsService = Application.Resolve <ISignalsService>();
ITradingService tradingService = Application.Resolve <ITradingService>();
tradingService.Buy(new BuyOptions(buyRequest.Pair)
{
MaxCost = tradingService.GetPairConfig(buyRequest.Pair).BuyMaxCost,
IgnoreExisting = true,
ManualOrder = true,
Metadata = new OrderMetadata
{
BoughtGlobalRating = signalsService.GetGlobalRating()
}
});
return(new OkResult());
}
else
{
return(new BadRequestResult());
}
}
public ActionResult BuyService(BuyRequest request)
{
var service = paymentServices.CreateNewService(
request.DefinitionId,
request.Data.ToObjectDictionary()
);
if (IsCurrentUserAdmin())
{
var serviceDefinitionToActivate = dbContext.Services.Find(request.DefinitionId);
service.Activate(serviceDefinitionToActivate);
return(Redirect(Request.Headers["Referer"].ToString()));
}
string redirectUrl = string.Empty;
try
{
redirectUrl = orders.Create(
request.DefinitionId,
service.Id,
currentUserProvider.UserId,
Request.HttpContext.Connection.RemoteIpAddress.ToString(),
"/Payment/Notify/",
Flurl.Url.Combine(rootPath, "/Payment/Final")
);
}
catch (Exception)
{
//TODO: Log and display error
}
return(Redirect(redirectUrl));
}
private IEnumerator BuyRequest()
{
String loginToken = PlayerPrefs.GetString("login_token");
if (loginToken == null || loginToken.Length < 1)
{
Debug.Log("No login token");
yield break;
}
BuyRequest buyRequest = new BuyRequest();
buyRequest.token = loginToken;
buyRequest.buildingType = Constants.Buildings.TYPE_FARM;
WWWForm form = new WWWForm();
Debug.Log("json request: " + JsonUtility.ToJson(buyRequest));
form.AddField("json", JsonUtility.ToJson(buyRequest));
using (UnityWebRequest www = UnityWebRequest.Post(ENDPOINT + "/buy", form)) {
yield return(www.Send());
Debug.Log("text: " + www.downloadHandler.text);
if (www.isNetworkError)
{
Debug.Log(www.error);
}
else if (www.responseCode != 200)
{
Debug.Log("Failed with response code: " + www.responseCode);
}
else
{
BuyResponse resp = JsonUtility.FromJson <BuyResponse>(www.downloadHandler.text);
if (resp == null)
{
Debug.Log("null resp");
yield break;
}
if (resp.error != null)
{
Debug.Log("error: " + resp.error);
}
else if (resp.building == null)
{
Debug.Log("no building returned");
}
else
{
Debug.Log("Bought building: " + resp.building.id + " last collected: " + resp.building.lastCollected);
}
};
}
}
public BuyResponse Post(BuyRequest request)
{
if (request == null)
{
return(new BuyResponse(BuyResponseStatus.DeserializationException));
}
User user;
BuyReceipt buyReceipt;
var isFree = Lottery.IsFree();
try
{
user = _userService.GetUserByBadge(request.Badge);
request.Validate(ConfigurationFacade.RemoteHashKey);
buyReceipt = _transactionService.Buy(request);
}
catch (InvalidBadgeException)
{
return(new BuyResponse(request.Badge));
}
catch (InvalidHashException)
{
return(new BuyResponse(BuyResponseStatus.InvalidHash));
}
catch (InvalidProductException)
{
return(new BuyResponse(BuyResponseStatus.InvalidProduct));
}
catch (InvalidTimestampException)
{
return(new BuyResponse(BuyResponseStatus.InvalidTimestamp));
}
catch (InsufficientFundsException)
{
return(new BuyResponse(BuyResponseStatus.InsufficientFunds));
}
var balanceString = buyReceipt.NewBalance.ToString("N", CultureInfo.InvariantCulture.NumberFormat);
var validResponse = new BuyResponse(user.Name, balanceString, request.Product);
if (!isFree)
{
return(validResponse);
}
try
{
Reimburse(buyReceipt.AmountDebited, user.Id);
}
catch (Exception e)
{
_logService.Log(e.ToString());
return(validResponse);
}
return(new BuyResponse(BuyResponseStatus.Free));
}
public async Task <IActionResult> Buy(BuyRequest request, CancellationToken cancellationToken)
{
var client = await _clientService.GetByIdAsync(request.Id, cancellationToken);
client.Total += request.Total;
await _clientService.UpdateAsync(client, new[] { nameof(Client.Total) }, cancellationToken);
return(Ok());
}
public void OnClickBuy()
{
WindowManager.Instance.HideWindow(WindowID.MsgTreeSelectPanel);
BuyRequest request = new BuyRequest();
AsyncBuyRequest async = new AsyncBuyRequest(request);
async.TryRequest();
}
public async Task Purchase(BuyRequestDTO buyRequestDto)
{
User user = await _context.User.FirstOrDefaultAsync(u => u.UserName == buyRequestDto.Username);
List <Book> books = _context.Book.Where(b => buyRequestDto.BookIds.Contains(b.Id)).ToList();
if (user == null || books == null)
{
throw new EntityInvalidationException("Gabim");
}
// Calculate the total price
int totalPrice = 0;
foreach (Book book in books)
{
totalPrice += book.Price;
}
// Generate the unique token identifier
string code = Guid.NewGuid().ToString("n").Substring(0, 12);
BuyRequest buyRequest = new BuyRequest
{
User = user,
Address = buyRequestDto.Address,
Date = DateTime.Now,
ExpireDate = DateTime.Now.AddDays(5),
Status = "PENDING",
BuyRequestTokenIdentifier = code
};
await _context.BuyRequest.AddAsync(buyRequest);
await _context.SaveChangesAsync();
// Associating books to the BookBuyRequest table with the current Request
foreach (Book book in books)
{
BookBuyRequest bookBuyRequest = new BookBuyRequest
{
Book = book,
BuyRequest = buyRequest
};
await _context.BookBuyRequests.AddAsync(bookBuyRequest);
}
// Generate QR code for the request
_QRServices.GenerateQRCode(code);
// Add points to the user
// More complex -> include a formula like this: nrOfBuys + (a parabola formula to avoid exponential growth) ## NEEDS RESTART
user.Points = (int)(totalPrice * 0.1);
await _context.SaveChangesAsync();
}
public void Test1Buy()
{
//var mock = new Mock<ISerializer>;
BuyRequest buy = new BuyRequest();
int i = buy.sendBuyRequest(4, 2, 10);
Assert.AreNotEqual(-1, i);
i = buy.sendBuyRequest(1000000900, 3, 10);
Assert.AreEqual(-1, i);
}
public async Task <ActionResult <BuyResponse> > Buy([FromBody] BuyRequest request)
{
var paymentInfo = await _paymentService.Buy(request.ProductId);
return(new ActionResult <BuyResponse>(new BuyResponse
{
QrId = paymentInfo.QrId,
EncodedQr = paymentInfo.EncodedQr
}));
}
public void FixtureSetUp()
{
buy = new int[4];
BuyRequest s = new BuyRequest();
buy[0] = s.sendBuyRequest(3, 5, 3);
buy[1] = s.sendBuyRequest(5, 2, 3);
buy[2] = s.sendBuyRequest(2, 3, 3);
buy[3] = s.sendBuyRequest(1, 4, 3);
// this code runs once no matter how many tests are in this class
}
public BuyResponse Buy(BuyRequest request)
{
var response = new BuyResponse();
try
{
// Подсчитываем общее кол-во монет с учетом вновь прибывших
var coinsBuffer = _coinService.GetAllCoins().OrderByDescending(x => x.Value);
var totalCoins = 0;
foreach (var coin in coinsBuffer)
{
foreach (var coinOrder in request.Coins)
{
if (coin.Id == coinOrder.Key)
{
totalCoins += coin.Value * coinOrder.Value;
coin.Count += coinOrder.Value;
}
}
}
var refund = totalCoins - request.TotalCost;
if (refund != 0)
{
response.Refund = CalculateRefund(refund, coinsBuffer);
}
foreach (var drinkId in request.Drinks)
{
var drink = _drinkService.GetDrinkById(drinkId);
if (drink != null)
{
drink.Count += -1;
_drinkService.Update(drink);
}
}
if (response.Refund != null && response.Refund.Count > 0)
{
foreach (var itemDictionary in response.Refund)
{
itemDictionary.Key.Count += -itemDictionary.Value;
_coinService.Update(itemDictionary.Key);
}
}
}
catch (Exception e)
{
response.ErrorCode = 1;
response.Message = e.Message;
}
return(response);
}
public async Task ConfirmDeliveryStatus(string filename)
{
string buyRequestToken = _QRServices.DecodeQRCode(filename);
BuyRequest buyRequest = await _context.BuyRequest.SingleOrDefaultAsync(b => b.BuyRequestTokenIdentifier == buyRequestToken && b.Status != "DELIVERED");
if (buyRequest == null)
{
throw new EntityInvalidationException("No Buy Request exists with this QR code");
}
buyRequest.Status = "DELIVERED";
await _context.SaveChangesAsync();
}
private void button1_Click(object sender, EventArgs e)
{
//send
int commodity = (int)numericUpDown1.Value;
int amount = (int)numericUpDown2.Value;
int price = (int)numericUpDown3.Value;
BuyRequest req = new BuyRequest(commodity, amount, price);
IMarketResponse res = InterperatorPB.sendRequest(req);
MessageBox.Show(this, res.ToString());
myLogger.Info("User clicked BUY: {commodity: " + commodity + ", price: " + price + ", amount: " + amount + "}");
}
public int SendBuyRequest(int price, int commodity, int amount)
{
BuyRequest buyReq = new BuyRequest(commodity, amount, price); //create and define buy request
String output = client.SendPostRequest <BuyRequest>(loginInfo.GetURL(), loginInfo.GetUser(), loginInfo.GetToken(), buyReq);
if (Utils.Shell.isNumeric(output)) //if the request output is numeric then it succeeded
{
return(Int32.Parse(output));
}
else // the request failed , printing the output
{
Console.WriteLine(output);
return(-1);
}
}
public BuyReceipt Buy(BuyRequest request)
{
Transaction transaction;
lock (_transactionLock)
{
transaction = GenerateTransaction(request);
_drinksContext.Transactions.Add(transaction);
_drinksContext.SaveChanges();
}
var newBalance = _userService.GetBalance(transaction.UserId);
return(new BuyReceipt(newBalance, -transaction.Amount));
}
public int Post(BuyRequest request)
{
try
{
BuyDataAccess _dataAccess = new BuyDataAccess();
_dataAccess.Insert(request);
//Retorna 204: La peticion ha sido manejada con exito y la respuesta no tiene contenido
return(204);
}
catch (Exception ex)
{
Console.WriteLine("BuyModel.Post : ERROR : " + ex.Message);
//Error interno del servidor
return(500);
}
}
public bool Buy(int id, string email, int quantity)
{
BuyRequest buyRequest = new BuyRequest();
bool AvailabilityCheck = CheckAvailability(id, quantity);
if (AvailabilityCheck)
{
buyRequest.ProductId = id;
buyRequest.Email = email;
buyRequest.quantity = quantity;
userRepository.Buy(buyRequest);
StockUpdate(id, buyRequest.quantity);
return(true);
}
return(false);
}
// trainId odnosi sie do routeId
public bool SendBuyRequest(BuyRequest buyRequest)
{
string message = buyRequest.TravelId + "?"
+ buyRequest.UserId + "?"
+ Cities.list[Convert.ToInt32(buyRequest.FromStation) - 1].Name + "?"
+ Cities.list[Convert.ToInt32(buyRequest.ToStation) - 1].Name + "?"
+ buyRequest.Amount + "?"
+ Tickets.list[Convert.ToInt32(buyRequest.TicketType) - 1].Name;
Task <string> t = InvokeAsync(message, QueueName.buyQueue);
t.Wait();
bool result = ParseBuyResponse(t.Result);
return(result);
}
private static async Task <Purchase> CreatePurchase(HttpClient client, AccountDetails createdAccountDetails)
{
var requestData = new BuyRequest()
{
AccountNumber = createdAccountDetails.AccountNumber,
MaxUnitPrice = 150,
ProductCode = Constants.ProductA,
Quantity = Constants.QuantityPurchased
};
var response = await client.PostAsJsonAsync("/api/Purchases", requestData);
response.EnsureSuccessStatusCode();
var responseData = await response.Content.ReadAsJsonAsync <Purchase>();
Assert.True(responseData.Success);
return(responseData);
}
public void Checkout(BuyRequest request)
{
ShoppingService.Checkout(
request.PromoCode,
DateTime.Now,
() => {
var member = MemberRepository.FindById(ContextualMemberId);
if (member == null)
{
throw new InternalException(ContextualMemberId);
}
return(member);
},
() => ItemRepository.FindByIds(request.ItemIds) ?? new Item[] { },
total => {
LoggingService.Log(LogLevel.Info, $"Member {ContextualMemberId} charged {total}");
PaymentService.Charge(ContextualMemberId, total);
});
}
public IMarketResponse SendBuyRequest(int price, int commodity, int amount)
{
BuyRequest buyReq = new BuyRequest(commodity, amount, price); //create and define buy request
MBuySell marketResponse = new MBuySell();
try
{
marketResponse.id = client.SendPostRequest <BuyRequest>(url, user, privateKey, buyReq);
myLogger.Info("Sent Buy Request{commodity:" + commodity + ", price:" + price + ", amount:" + amount + ", url:" + url + "}");
}
catch (Exception e)
{
return(catchMethod(e));
}
myHistory.Info("Sent Buy Request-\r\ncommodity:" + commodity + ", price:" + price + ", amount:" + amount + "\nResponse: " + marketResponse.ToString());
return(marketResponse);
}
private static async Task <Purchase> MakePurchase(HttpClient httpClient, Guid account_code, string productCode, int maxUnitPrice, int quantity)
{
var requestData = new BuyRequest()
{
AccountNumber = account_code,
MaxUnitPrice = maxUnitPrice,
ProductCode = productCode,
Quantity = quantity
};
var response = await httpClient.PostAsJsonAsync("/api/Purchases", requestData);
response.EnsureSuccessStatusCode();
var responseData = await response.Content.ReadAsJsonAsync <Purchase>();
//TODO: Check the purchase was successful
return(responseData);
}
protected virtual IActionResult Buy(BuyRequest buyRequest)
{
if (buyRequest == null)
{
return(BadRequest());
}
Buy buy;
try
{
buy = AdvisorServices.Buy(GetUser(), buyRequest.Address, buyRequest.PortfolioId, buyRequest.Days, buyRequest.Goal?.GoalOptionId,
buyRequest.Goal?.Timeframe, buyRequest.Goal?.Risk, buyRequest.Goal?.TargetAmount, buyRequest.Goal?.StartingAmount,
buyRequest.Goal?.MonthlyContribution);
}
catch (ArgumentException ex)
{
return(BadRequest(new { error = ex.Message }));
}
return(Ok(new { id = buy.Id }));
}
public ActionResult CompletedOrder(int id) //This method removes the customer order detail
{
if (Session["AdminEmail"] != null)
{
CompletedOrders completedOrders = new CompletedOrders();
BuyRequest buyRequest = onlineShoppingDbcontext.BuyRequests.Where(x => x.RequestId == id).FirstOrDefault();
completedOrders.RequestId = buyRequest.RequestId;
completedOrders.ProductId = buyRequest.ProductId;
completedOrders.Email = buyRequest.Email;
completedOrders.quantity = buyRequest.quantity;
completedOrders.DateTime = DateTime.Now;
onlineShoppingDbcontext.CompletedOrders.Add(completedOrders);
onlineShoppingDbcontext.SaveChanges();
productService.DeleteOrder(id);
return(RedirectToAction("CustomerOrders"));
}
else
{
return(RedirectToAction("AdminLogin", "Account"));
}
}
public async Task A_Transaction_Will_Be_Created()
{
var client = _factory.CreateDefaultClient();
var createdAccountDetails = await CreateAccount(client);
var requestData = new BuyRequest()
{
AccountNumber = createdAccountDetails.AccountNumber,
MaxUnitPrice = 150,
ProductCode = Constants.ProductA,
Quantity = 10
};
var response = await client.PostAsJsonAsync("/api/Purchases", requestData);
response.EnsureSuccessStatusCode();
var responseData = await response.Content.ReadAsJsonAsync <Purchase>();
Assert.True(responseData.Success);
}
public void Insert(BuyRequest request)
{
try
{
MASFARMACIADEVContext context = new MASFARMACIADEVContext();
BuysEntity buysEntity = new BuysEntity()
{
UploadDate = request.UploadDate,
TotalAmount = request.TotalAmount,
IdClient = request.IdClient,
IdOrder = request.IdOrder
};
context.BuysEntity.Add(buysEntity);
context.SaveChanges();
}
catch (Exception ex)
{
Console.WriteLine("BuyDataAccess.Insert : ERROR : " + ex.Message);
throw;
}
}
public ActionResult ZnalezionePolaczenia(FormCollection form)
{
BuyResponse response = new BuyResponse();
string train = form["checkTrain"].ToString();
int amount = int.Parse(form["ILOSC"]);
string ticket_type = form["ticket"].ToString();
Rpc rpc = new Rpc();
BuyRequest buyRequest = new BuyRequest()
{
TravelId = train,
UserId = Session["userID"].ToString(),
FromStation = Session["from"].ToString(),
ToStation = Session["to"].ToString(),
Amount = amount.ToString(),
TicketType = ticket_type
};
bool buyResponse = rpc.SendBuyRequest(buyRequest);
return(RedirectToAction("konto"));
}
public JsonResult PublishBuyRequest(PublishBuyRequestPostModel model)
{
var result = new PublishBuyRequestPostResult();
using (var db = DbContextFactory.CreateDbContext())
{
Account acc;
if (!TokenXCodeValidation.Validate(model, db, out acc))
throw new HttpException(Resources.ErrorReLogin);
var shop = db.Shops.Include("Account").First(a => a.Id == model.ShopId && a.Account.Id == acc.Id );
var buyRequest = new BuyRequest()
{
CreateTime = DateTime.Now,
UpdatedTime = DateTime.Now,
GoodsId = model.GoodsId,
PlanCount = model.PlanCount,
PlanTime = model.PlanTime,
Price = model.Price,
RealCount = 0,
SearchWord = model.SearchWord,
Shop = shop,
Account = acc,
YqBindPhone = model.YqBindPhone,
YqBindSfz = model.YqBindSfz,
YqManualCheck = model.YqManualCheck,
YqMonthCount = model.YqMonthCount,
YqRegisterDate = model.YqRegisterDate,
YqUserLevel = model.YqUserLevel,
YqWeekCount = model.YqWeekCount,
Sku = model.Sku,
Details = model.Details,
Salary = model.Salary,
};
db.BuyRequests.Add(buyRequest);
db.SaveChanges();
result.Id = buyRequest.Id;
}
return new JsonResult() { Data = result };
}
public IActionResult Buy(BuyRequest buyRequest)
{
if (Application.Resolve <ICoreService>().Config.ReadOnlyMode)
{
return(new BadRequestResult());
}
if (!string.IsNullOrWhiteSpace(buyRequest.Pair) && buyRequest.Amount > 0)
{
ITradingService tradingService = Application.Resolve <ITradingService>();
tradingService.Buy(new BuyOptions(buyRequest.Pair)
{
Amount = buyRequest.Amount,
IgnoreExisting = true,
ManualOrder = true
});
return(new OkResult());
}
return(new BadRequestResult());
}
