public static void BuyOneCoffeFailedCountTest()
{
var machine = new VendingMachine();
var userBug = new BugModel();
userBug.InitUserBug();
var twoRuble = new CoinModel()
{
Value = CoinValueEnum.Two, CoinType = CoinTypeEnum.Ruble
};
var tenRuble = new CoinModel()
{
Value = CoinValueEnum.Ten, CoinType = CoinTypeEnum.Ruble
};
userBug.InsertCoinToMachine(machine, twoRuble);
userBug.InsertCoinToMachine(machine, twoRuble);
userBug.InsertCoinToMachine(machine, tenRuble);
userBug.InsertCoinToMachine(machine, tenRuble);
const ProductTypeEnum itemType = ProductTypeEnum.Coffee;
machine.BuyProduct(itemType);
}
public IActionResult EditPage(int id)
{
CoinModel coin = null;
using (var db = new BusinessLogic.BusinessLogic())
{
var players = Mapper.Map <List <CoinModel> >(db.GetCoins());
foreach (CoinModel model in players)
{
if (model.CoinId == id)
{
coin = model;
break;
}
}
}
if (coin != null)
{
currentEditionID = coin.CoinId;
ViewData["CoinName"] = coin.Name;
ViewData["CoinCost"] = coin.Cost;
ViewData["CoinLink"] = coin.Link;
ViewData["CoinDollarPrice"] = coin.DollarPrice;
ViewData["CoinZlotyPrice"] = coin.ZlotyPrice;
ViewData["CoinIsSold"] = coin.IsSold;
ViewData["CoinEnglishName"] = coin.EnglishName;
ViewData["CoinPolishName"] = coin.PolishName;
}
return(View());
}
private static List <CoinOptimized> CovertCoinDateTime(CoinModel coin, int dataHours)
{
var optimized = new List <CoinOptimized>();
coin = RemoveExcess(coin, dataHours);
foreach (var item in coin.Data)
{
var dtDateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
optimized.Add(new CoinOptimized()
{
Time = dtDateTime.AddSeconds(Convert.ToDouble(item.Time)).ToLocalTime(),
Close = item.Close,
High = item.High,
Low = item.Low,
Open = item.Open,
VolumeTo = item.VolumeTo,
VolumeFrom = item.VolumeFrom
});
}
var isValid = CheckForGaps(optimized);
if (isValid)
{
return(optimized);
}
return(null);
}
//Overload method for item
public ItemModel GetItemModel(string type, Vector2 coordinates, Vector2 velocity)
{
Coordinates = coordinates;
Velocity = velocity;
ItemModel itemModel = null;
if (type.Equals("fireflower"))
{
itemModel = new FireFlowerModel(ItemEnemySpriteFactory, Coordinates, Velocity, CollisionGrid);
}
else if (type.Equals("coin"))
{
itemModel = new CoinModel(ItemEnemySpriteFactory, Coordinates, Velocity);
}
else if (type.Equals("redmushroom"))
{
itemModel = new RedMushroomModel(ItemEnemySpriteFactory, Coordinates, Velocity, CollisionGrid);
}
else if (type.Equals("greenmushroom"))
{
itemModel = new GreenMushroomModel(ItemEnemySpriteFactory, Coordinates, Velocity, CollisionGrid);
}
else if (type.Equals("star"))
{
itemModel = new SuperStarModel(ItemEnemySpriteFactory, Coordinates, Velocity, CollisionGrid);
}
return(itemModel);
}
public async Task <IActionResult> PutOne(string slug, int id, [FromBody] CoinModel body)
{
await Db.Connection.OpenAsync();
var query = new CoinPostQuery(Db);
var result = await query.FirstPostAsync(slug, id);
if (result is null)
{
return(new NotFoundResult());
}
result.Slug = body.Slug;
result.Last = body.Last;
result.Max = body.Max;
result.Min = body.Min;
result.Buy = body.Buy;
result.Sell = body.Sell;
result.Open = body.Open;
result.Vol = body.Vol;
result.Trade = body.Trade;
result.Trades = body.Trades;
result.Vwap = body.Vwap;
result.Money = body.Money;
result.Date = body.Date;
await result.UpdateAsync();
return(new OkObjectResult(result));
}
public async Task <CoinModel> GetCoinByPosition(CoinModel model)
{
var coinEntity = _mapper.Map <Coin>(model);
coinEntity = await _gameRepository.GetCoinByPosition(coinEntity);
if (coinEntity == null)
{
return(null);
}
coinEntity.IsOpened = true;
await _gameRepository.UpdateCoin(coinEntity);
var gameEntity = await _gameRepository.GetGameById(model.GameId);
//Check is game ended and update game
await CheckEndGame(gameEntity);
//await _gameRepository.UpdateGame(gameEntity);
//Return only requsted coin
gameEntity.Coins = null;
coinEntity.Game = gameEntity;
var coinModel = _mapper.Map <Coin, CoinModel>(coinEntity);
return(coinModel);
}
public static void AddMoneyFromUserToMachineAndChangeSummaryTest()
{
var userBug = new BugModel();
userBug.InitUserBug();
var twoRubleCounts = userBug.TwoRurPort.Count;
var machine = new VendingMachine();
var twoRublesMachine = machine.ShowTwoRublesCount();
var userMoneyBefore = machine.UserSumRur;
var twoRuble = new CoinModel()
{
Value = CoinValueEnum.Two, CoinType = CoinTypeEnum.Ruble
};
userBug.InsertCoinToMachine(machine, twoRuble);
Assert.AreEqual(userBug.ShowTwoRublesCount(), twoRubleCounts - 1);
Assert.AreEqual(machine.ShowTwoRublesCount(), twoRublesMachine + 1);
var userMoneyAfter = machine.UserSumRur;
Assert.AreEqual(userMoneyBefore, 0);
Assert.AreEqual(userMoneyAfter, (int)twoRuble.Value);
}
public CoinHistoryViewModel(string coin, string format)
{
try
{
List <CoinValue> BeCoins = FactoryBL.get().getCoinHistory(coin, format);
history = (from c in BeCoins
select new CoinModel(coin, c.date, c.CoinValueId, 0)).ToList();
if (history.Count == 1) //precaution for break mode ,if the graph has only single value (y = 4 for example) the code will enter break mode
{
CoinModel tempC = history.First();
history.Add(new CoinModel(tempC.coin, tempC.lastUpdate - TimeSpan.FromDays(1), tempC.value + 0.0000001));
history.Add(new CoinModel(tempC.coin, tempC.lastUpdate - TimeSpan.FromDays(2), tempC.value));
}
if (FactoryBL.get().GetSlope(coin) == 0) //another reprecaution for break mode ,so the graph won't have only 1 value and enter a break mode
{
CoinModel tempC = history.First();
history.Remove(tempC);
history.Add(new CoinModel(tempC.coin, tempC.lastUpdate - TimeSpan.FromDays(1), tempC.value + 0.0000001));
}
}
catch (Exception ex)
{
history = new List <CoinModel>();
history.Add(new CoinModel("NOT FOUND", DateTime.Now, 1));
}
YFormatter = valueTostring;
}
public void TestMethod_CoinDetail()
{
VendingMachineProcess vendingMachingProcess = new VendingMachineProcess();
int coinSNo = 3;
CoinModel result = vendingMachingProcess.FindAndReturnCoin(coinSNo);
Assert.AreEqual(result.Coin, "Quarters");
}
public static void PayoutMoneyFromMachineTest()
{
var userBug = new BugModel();
userBug.InitUserBug();
var machine = new VendingMachine();
machine.InitMachine();
var oneRuble = new CoinModel()
{
Value = CoinValueEnum.One, CoinType = CoinTypeEnum.Ruble
};
var twoRuble = new CoinModel()
{
Value = CoinValueEnum.Two, CoinType = CoinTypeEnum.Ruble
};
var tenRuble = new CoinModel()
{
Value = CoinValueEnum.Ten, CoinType = CoinTypeEnum.Ruble
};
userBug.InsertCoinToMachine(machine, oneRuble);
userBug.InsertCoinToMachine(machine, oneRuble);
userBug.InsertCoinToMachine(machine, oneRuble);
userBug.InsertCoinToMachine(machine, twoRuble);
userBug.InsertCoinToMachine(machine, twoRuble);
userBug.InsertCoinToMachine(machine, tenRuble);
userBug.InsertCoinToMachine(machine, tenRuble);
var userBugSumBefore = userBug.RublesSum();
int tenRublesCountBefore = userBug.ShowTenRublesCount();
int fiveRublesCountBefore = userBug.ShowFiveRublesCount();
int twoRublesCountBefore = userBug.ShowTwoRublesCount();
var machineSumBefore = machine.MachineBagSum();
var machineUserBugBefore = machine.UserSumRur;
machine.PayOut(userBug);
const int paySumInBug = 27;
var userSumAfter = machine.UserSumRur;
Assert.AreEqual(userSumAfter, 0);
Assert.AreEqual(machineUserBugBefore, paySumInBug);
Assert.AreEqual(userBug.RublesSum(), userBugSumBefore + paySumInBug);
Assert.AreEqual(machine.MachineBagSum(), machineSumBefore - paySumInBug);
Assert.AreEqual(userBug.ShowTenRublesCount(), tenRublesCountBefore + 2);
Assert.AreEqual(userBug.ShowFiveRublesCount(), fiveRublesCountBefore + 1);
Assert.AreEqual(userBug.ShowTwoRublesCount(), twoRublesCountBefore + 1);
}
public static void AddMoneyFromUserToMachineTest()
{
var userBug = new BugModel();
userBug.InitUserBug();
var userBugSumBefore = userBug.RublesSum();
var machine = new VendingMachine();
machine.InitMachine();
var oneRuble = new CoinModel()
{
Value = CoinValueEnum.One, CoinType = CoinTypeEnum.Ruble
};
var twoRuble = new CoinModel()
{
Value = CoinValueEnum.Two, CoinType = CoinTypeEnum.Ruble
};
var tenRuble = new CoinModel()
{
Value = CoinValueEnum.Ten, CoinType = CoinTypeEnum.Ruble
};
var machineSumBefore = machine.MachineBagSum();
var machineUserBugBefore = machine.UserSumRur;
bool o1 = userBug.InsertCoinToMachine(machine, oneRuble);
bool o2 = userBug.InsertCoinToMachine(machine, oneRuble);
bool o3 = userBug.InsertCoinToMachine(machine, oneRuble);
bool two1 = userBug.InsertCoinToMachine(machine, twoRuble);
bool two2 = userBug.InsertCoinToMachine(machine, twoRuble);
bool ten1 = userBug.InsertCoinToMachine(machine, tenRuble);
bool ten2 = userBug.InsertCoinToMachine(machine, tenRuble);
Assert.IsTrue(o1);
Assert.IsTrue(o2);
Assert.IsTrue(o3);
Assert.IsTrue(two1);
Assert.IsTrue(two2);
Assert.IsTrue(ten1);
Assert.IsTrue(ten2);
const int paySumInBug = 27;
var userSumAfter = machine.UserSumRur;
Assert.AreEqual(userSumAfter, paySumInBug);
Assert.AreEqual(machineUserBugBefore, 0);
Assert.AreEqual(machine.MachineBagSum(), machineSumBefore + paySumInBug);
Assert.AreEqual(userBug.RublesSum(), userBugSumBefore - paySumInBug);
}
public async Task <IActionResult> Post([FromBody] CoinModel body)
{
await Db.Connection.OpenAsync();
body.Db = Db;
await body.InsertAsync();
return(new OkObjectResult(body));
}
//switch graph data
internal void ChangeCurrency(object coinObj, PropertyChangedEventArgs arg)
{
if (!(coinObj is CoinModel))
{
return;
}
CoinModel coin = (CoinModel)coinObj;
History.ChangeCoin(coin.coin);
}
public static bool PayOut(this CoinsPort port, CoinModel coin)
{
bool resultOk = (port.Count > 0 && (port.CoinType == coin.CoinType && port.CoinValue == coin.Value));
if (resultOk)
{
port.Count--;
}
return(resultOk);
}
public CoinModel Create()
{
var result = new CoinModel(new Coin(), _serializableCacheService, _dialogService, _imageReaderService, _imageCacheService)
{
Year = DateTime.Now.Year
};
_serializableCacheService.Add(result);
return(result);
}
public static void BuyOneCoffeOkAndPayOutTest()
{
var machine = new VendingMachine();
machine.InitMachine();
var coffeCupsCountBefore = machine.CoffeePort.ProductCount;
var userBug = new BugModel();
userBug.InitUserBug();
var oneRuble = new CoinModel()
{
Value = CoinValueEnum.One, CoinType = CoinTypeEnum.Ruble
};
var twoRuble = new CoinModel()
{
Value = CoinValueEnum.Two, CoinType = CoinTypeEnum.Ruble
};
var tenRuble = new CoinModel()
{
Value = CoinValueEnum.Ten, CoinType = CoinTypeEnum.Ruble
};
userBug.InsertCoinToMachine(machine, oneRuble);
userBug.InsertCoinToMachine(machine, twoRuble);
userBug.InsertCoinToMachine(machine, twoRuble);
userBug.InsertCoinToMachine(machine, tenRuble);
userBug.InsertCoinToMachine(machine, tenRuble);
var userBugSumBefore = userBug.RublesSum();
const ProductTypeEnum itemType = ProductTypeEnum.Coffee;
var success = machine.BuyProduct(itemType);
machine.PayOut(userBug);
Assert.IsTrue(success.Result);
var coffeCupsCountAfter = machine.CoffeePort.ProductCount;
Assert.AreEqual(coffeCupsCountAfter, coffeCupsCountBefore - 1);
var userSubAfter = userBug.RublesSum();
Assert.AreEqual(userSubAfter, userBugSumBefore + 7);
Assert.AreEqual(machine.UserSumRur, 0);
}
public ActionResult Coin(long id)
{
CoinDTO dto = adminService.GetCoin(id);
CoinModel model = new CoinModel
{
Id = dto.Id,
Count = dto.Count,
Denomination = dto.Denomination,
Lock = dto.Lock
};
return(View(model));
}
private void SpawnCoin()
{
var coinGO = GameObject.Instantiate(_coinPrefab, _coinsSpawnRoot.transform);
coinGO.transform.position = new Vector3(Random.Range(50, -50), 50, Random.Range(30, -30));
var coinMv = coinGO.AddComponent <CoinMV>();
var coinModel = new CoinModel();
coinMv.Initialize(coinModel);
_coins.Add(coinModel);
}
public async Task <ActionResult <CoinModel> > GetCoinByPosition([FromBody] CoinModel model)
{
try
{
var result = await _gameService.GetCoinByPosition(model);
return(result);
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
private List <CoinOptimized> NormilizeModel(CoinModel coin, int dataHours)
{
if (coin?.Data == null ||
coin.Data.Count == 0 ||
coin.Data.Count < dataHours)
{
return(null);
}
var converted = CovertCoinDateTime(coin, dataHours);
return(converted);
}
/// <summary>
/// Add a CoinModel data point to an Interval List
/// </summary>
/// <param name="cm">CoinModel</param>
public bool Add(CoinModel cm)
{
lock (Intervals)
{
Intervals[MarketTimes.One].Add(cm);
Intervals[MarketTimes.Three].Add(cm);
Intervals[MarketTimes.Five].Add(cm);
Intervals[MarketTimes.Fifteen].Add(cm);
Intervals[MarketTimes.Thirty].Add(cm);
}
return(true);
}
public IActionResult SaveChanges(int id, string name, string surname, string year, bool health, int salary)
{
CoinModel coin = new CoinModel()
{
CoinId = currentEditionID,
Name = name,
};
using (var db = new BusinessLogic.BusinessLogic())
db.UpdateCoin(Mapper.Map <CoinBL>(coin));
return(Redirect("~/Home/Index"));
}
public async Task <MessageDialogResult> ThrowWillBeRemovedMessageBox(CoinModel coin)
{
var message = string.Format(Properties.Resources.RemoveCoinMessageBoxText, coin.Title);
return(await this.ShowMessageAsync(Properties.Resources.RemoveCoinMessageBoxTtitle
, message
, MessageDialogStyle.AffirmativeAndNegative
, new MetroDialogSettings
{
AffirmativeButtonText = "Yes",
NegativeButtonText = "No"
}));
}
public void TestMethod_CoinDetail_Negative()
{
VendingMachineProcess vendingMachingProcess = new VendingMachineProcess();
int coinSNo = 5;
CoinModel result = vendingMachingProcess.FindAndReturnCoin(coinSNo);
string finalResult = null;
if (result != null)
{
finalResult = result.Coin;
}
Assert.AreEqual(finalResult, null);
}
public static void AddtwoRublesFromUserToMachineFailedTest()
{
var userBug = new BugModel();
var machine = new VendingMachine();
var twoRuble = new CoinModel()
{
Value = CoinValueEnum.Two, CoinType = CoinTypeEnum.Ruble
};
bool result = userBug.InsertCoinToMachine(machine, twoRuble);
Assert.IsFalse(result);
}
public override async void Init(object initData)
{
try
{
CoinModel = initData as CoinModel;
var result = await _service.GetDetailCoinsAsync(CoinModel.Simbolo, DateTime.Now.ToString("MM-dd-yyyy")).ConfigureAwait(true);
Details = new ObservableCollection <DetailCoinModel>(result.Value);
}
catch (ApiException e)
{
Console.WriteLine(e);
}
}
public void CollectCoin(CoinModel coin)
{
if (_coins.Contains(coin) == false)
{
return;
}
coin.IsDead = true;
_coins.Remove(coin);
_coinsCollected++;
CollectedCoinsUpdateSignal.Dispatch(_coinsCollected);
}
public IActionResult AddCoin(string title, int cost, string link)
{
CoinModel coin = new CoinModel()
{
Name = title,
Link = link,
Cost = cost
};
using (var db = new BusinessLogic.BusinessLogic())
db.AddCoin(Mapper.Map <CoinBL>(coin));
return(Redirect("~/Home/Index"));
}
public IActionResult OnPostAddCoin()
{
if (!ModelState.IsValid)
{
return(Page());
}
else
{
if (!string.IsNullOrEmpty(SelectedCoin))
{
if (int.TryParse(SelectedCoinQuantity, out int quantity))
{
if (quantity > 0 && quantity < 40)
{
CoinModel coin = new CoinModel
{
Amount = Coins[SelectedCoin],
Name = SelectedCoin
};
List <CoinModel> coinsToAdd = new List <CoinModel>();
for (int i = 0; i < quantity; i++)
{
coinsToAdd.Add(coin);
}
_dataAccess.CoinInventoryAddCoins(coinsToAdd);
Message = $"Successfully added {quantity} {SelectedCoin}";
}
else
{
Message = "Number must be greater than 0 and less than 40";
}
}
else
{
Message = "Enter a number in quantity";
}
}
else
{
Message = "Please select a coin";
}
}
return(OnGet());
}
public CoinModel GetCoinByPosition(CoinModel model)
{
var coinEntity = Mapper.Map <Coin>(model);
coinEntity = _provider.GetCoinByPosition(coinEntity);
if (coinEntity == null)
{
return(null);
}
model = Mapper.Map <Coin, CoinModel>(coinEntity);
return(model);
}
