public ActionResult Withdraw(WithdrawViewModel withdrawViewModel)
{
if (ModelState.IsValid)
{
if (CardsService.HasEnoughMoney(User.CardId, Convert.ToDecimal(withdrawViewModel.Amount)))
{
if (OperationsService.WithdrawMoney(User.CardId, Convert.ToDecimal(withdrawViewModel.Amount)))
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Could not withdraw money. Try again");
}
}
else
{
ModelState.AddModelError("", "Not enough money on the card balance");
}
}
var currentCardBalance = CardsService.GetBalance(User.CardId);
ViewData["currentCardBalance"] = currentCardBalance;
return(View());
}
public ActionResult Withdraw()
{
var currentCardBalance = CardsService.GetBalance(User.CardId);
ViewData["currentCardBalance"] = currentCardBalance;
return(View());
}
public void Setup()
{
Settings.ActiveCardDataVersion = Info.Current.CardDataVersion;
Settings.HighestNotifiedCardDataVersion = Info.Current.CardDataVersion;
_cardsService = new CardsService();
}
protected void OnSearch(object sender, EventArgs e)
{
int manaCost = -1;
if (manaCostTextBox.Text.Length > 0)
{
manaCost = int.Parse(manaCostTextBox.Text);
}
CardType card = new CardType(nameTextBox.Text, abilityTextBox.Text, manaCost, rarityDropDownList.SelectedIndex, "");
ArrayList colors = new ArrayList();
foreach (ListItem item in colorsList.Items)
{
if (item.Selected)
{
colors.Add(item.Value);
}
}
ArrayList kinds = new ArrayList();
foreach (ListItem item in kindsList.Items)
{
if (item.Selected)
{
kinds.Add(item.Value);
}
}
cardsService = new CardsService(card);
cards = cardsService.GetSelectedCards(colors, kinds);
if (cards != null)
{
magicCardsGridView.DataSource = cards.Tables["AllMagicCards"];
magicCardsGridView.DataBind();
}
}
public ActionResult Index(LoginModel model)
{
var cardService = new CardsService();
using (var context = new BankDbContext())
{
if (!ModelState.IsValid)
{
return(View());
}
if (cardService.IsAuthenticate(model.CardNumber, model.PinCode))
{
FormsAuthentication.SetAuthCookie(model.CardNumber, false);
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "Incorrect card number or pincode!");
}
}
return(View());
}
public void GetPriceShouldReturnCorrectPrice(decimal expectedPrice, int visits)
{
var service = new CardsService(this.cardRepository.Object, this.qrcodeService.Object, this.notificationsService.Object);
var price = service.GetPrice(visits);
Assert.Equal(expectedPrice, price);
}
public async Task TestLocalDeckService()
{
var cardsService = new CardsService();
var service = new LocalDeckService(cardsService);
var decks = await service.GetSavedDecksAsync();
Assert.IsTrue(decks.Count == 1);
var defaultDeck = decks[0];
Assert.AreEqual(DeckType.GENERATED_DECK, defaultDeck.Type);
//create a deck
var newDeck = new Deck(Faction.THORNS)
{
Name = "Service Test Deck"
};
newDeck.Add(new Cards().All.First((c) => c.Faction == Faction.THORNS && c.Type != CardType.CHAMPION));
var savedDeck = await service.SaveDeckAsync(newDeck);
Assert.AreEqual(newDeck.ID, savedDeck.ID);
Assert.AreEqual(newDeck, savedDeck);
//test retrieving saved deck
service = new LocalDeckService(cardsService);
decks = await service.GetSavedDecksAsync();
var deck = decks[0];
Assert.AreEqual(savedDeck.ID, deck.ID);
//unmodified save
var timestamp = deck.LastModified;
savedDeck = await service.SaveDeckAsync(deck);
Assert.AreEqual(timestamp, savedDeck.LastModified);
//modified save
savedDeck.Description = "Modified Description";
savedDeck = await service.SaveDeckAsync(deck);
Assert.AreNotEqual(timestamp, savedDeck.LastModified);
Assert.IsTrue(await service.DeleteDeckAsync(deck));
service = new LocalDeckService(cardsService);
decks = await service.GetSavedDecksAsync();
Assert.IsTrue(decks.Count == 1);
defaultDeck = decks[0];
Assert.AreEqual(DeckType.GENERATED_DECK, defaultDeck.Type);
var restoredDeck = await service.RestoreLastDeletedDeck();
Assert.AreEqual(deck.ID, restoredDeck.ID);
}
public CardAddForm(Topic topic, string category, string deck)
{
InitializeComponent();
_topic = topic;
_category = category;
_deck = deck;
_cardsService = new CardsService();
}
public ResourcesExplorerForm(Topic topic)
{
InitializeComponent();
_topic = topic;
_categoriesService = new CategoriesService();
_decksService = new DecksService();
_cardsService = new CardsService();
RefreshCategories();
}
public async Task GetCardViewModelAsyncShouldReturnNull(string userId)
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Card>(db);
var service = new CardsService(repository, this.qrcodeService.Object, this.notificationsService.Object);
var result = await service.GetCardViewModelAsync <TestCardModel>(userId);
Assert.Null(result);
}
private void AddCards()
{
try
{
DataSet kindCardsDataSet = new CardsService().GetAllCards();
Utilities.AddToDropDownList(kindCardsDataSet, cardDropDownList, "AllMagicCards", "cardName", "cardId");
}
catch (Exception ex)
{
Debug.WriteLine(ex.StackTrace);
}
}
public async Task GenerateCardShouldReturnNewCard()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Card>(db);
var service = new CardsService(repository, this.qrcodeService.Object, this.notificationsService.Object);
var result = await service.GenerateCardAsync(new ApplicationUser());
Assert.IsType <Card>(result);
}
public static void AddRarities(DropDownList raritiesDropDownList)
{
try
{
CardsService cardsServices = new CardsService();
DataSet cardsDataSet = cardsServices.GetAllRarities();
Utilities.AddToDropDownList(cardsDataSet, raritiesDropDownList, "Rarities", "rarityName", "rarityId");
}
catch (Exception ex)
{
Debug.WriteLine(ex.StackTrace);
}
}
private static AppointmentsService PreperaAppointmentServiceWithAllDependencies(ApplicationDbContext db)
{
var repository = new EfDeletableEntityRepository <Appointment>(db);
var usersRepository = new EfDeletableEntityRepository <ApplicationUser>(db);
var skinProblemsRepository = new EfDeletableEntityRepository <SkinProblem>(db);
var clientSkinProblemRepository = new EfRepository <ClientSkinProblem>(db);
var cardsRepository = new EfDeletableEntityRepository <Card>(db);
var cloudinaryService = new Mock <ICloudinaryService>();
var usersService = new UsersService(
usersRepository,
skinProblemsRepository,
clientSkinProblemRepository,
cardsRepository,
cloudinaryService.Object);
var cardTypesRepository = new EfDeletableEntityRepository <TypeCard>(db);
var cardsService = new CardsService(
cardTypesRepository,
cardsRepository);
var categoriesRepository = new EfDeletableEntityRepository <Category>(db);
var categoryService = new CategoriesService(categoriesRepository);
var proceduresRepository = new EfDeletableEntityRepository <Procedure>(db);
var procedureReviewsRepository = new EfDeletableEntityRepository <Review>(db);
var procedureProductsRepository = new EfRepository <ProcedureProduct>(db);
var procedureStylistsRepository = new EfRepository <ProcedureStylist>(db);
var skinProblemProcedureRepository = new EfRepository <SkinProblemProcedure>(db);
var proceduresService = new ProceduresService(
proceduresRepository,
procedureReviewsRepository,
procedureProductsRepository,
procedureStylistsRepository,
skinProblemProcedureRepository,
repository,
categoryService);
var service = new AppointmentsService(
repository,
usersService,
cardsService,
proceduresService,
categoryService);
return(service);
}
public async Task TestLoadDeck_minimalData()
{
var deckJson = ReadDeckFile("minimum.dfd");
Assert.IsNotNull(deckJson);
var cardsService = new CardsService();
var service = new LocalDeckService(cardsService);
var deck = await service.OpenDeckDataAsync(deckJson);
Assert.IsNotNull(deck);
Assert.AreEqual(Faction.THORNS, deck.DeckFaction);
Assert.AreEqual(DeckType.EXTERNAL_DECK, deck.Type);
}
public CardEditForm(Topic topic, string category, string deck, Guid id)
{
InitializeComponent();
_topic = topic;
_category = category;
_deck = deck;
_cardsService = new CardsService();
_card = _cardsService.GetById(_topic, _category, _deck, id);
SetControlsValues(_card);
ToggleEditMode(false);
btnSave.Visible = false;
}
public async Task GenerateCardShouldHavePropertiesAfterCreation()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Card>(db);
var service = new CardsService(repository, this.qrcodeService.Object, this.notificationsService.Object);
var result = await service.GenerateCardAsync(new ApplicationUser());
Assert.NotNull(result.Id);
Assert.NotNull(result.UserId);
Assert.Equal(0, result.Visits);
}
public void Cleanup()
{
var cardsService = new CardsService();
var service = new LocalDeckService(cardsService);
var decksGetter = service.GetSavedDecksAsync().ContinueWith(async(t) =>
{
var decks = t.Result;
foreach (var deck in decks)
{
await service.DeleteDeckAsync(deck);
}
});
}
private void AddCards()
{
try
{
userCardService = new UserCardService();
DataSet userCardsDataSet = new CardsService().GetAllCards();
foreach (DataRow rows in userCardsDataSet.Tables["AllMagicCards"].Rows)
{
cardDropDownList.Items.Add(new ListItem(rows["cardName"].ToString()));
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.StackTrace);
}
}
public async Task TestLoadDeck_v1()
{
var deckJson = ReadDeckFile("v1.dfd");
Assert.IsNotNull(deckJson);
var cardsService = new CardsService();
var service = new LocalDeckService(cardsService);
var deck = await service.OpenDeckDataAsync(deckJson);
Assert.IsNotNull(deck);
Assert.AreEqual(Faction.THORNS, deck.DeckFaction);
Assert.AreEqual(DeckType.EXTERNAL_DECK, deck.Type);
Assert.AreEqual(30, deck.Count);
Assert.AreEqual("ThC002", deck.Champion.ID);
}
public BankScrapperAppService(
IMapper mapper,
AccountsService accountsService,
BillsService billsService,
CardsService cardsService,
CategoriesService categoriesService,
CustomersService customersService,
TransactionsService transactionsService)
{
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_accountsService = accountsService ?? throw new ArgumentNullException(nameof(accountsService));
_billsService = billsService ?? throw new ArgumentNullException(nameof(billsService));
_cardsService = cardsService ?? throw new ArgumentNullException(nameof(cardsService));
_categoriesService = categoriesService ?? throw new ArgumentNullException(nameof(categoriesService));
_customersService = customersService ?? throw new ArgumentNullException(nameof(customersService));
_transactionsService = transactionsService ?? throw new ArgumentNullException(nameof(transactionsService));
}
protected void OnRowUpdating(object sender, GridViewUpdateEventArgs e)
{
DataSet cardsDS = (DataSet)Cache["Cards"];
int selectedIndex = e.RowIndex;
string temp = magicCardsGridView.Rows[selectedIndex].Cells[0].Text;
int cardIds = int.Parse(temp);
DataRow row = cardsDS.Tables["AllMagicCards"].Rows.Find(cardIds);
for (int i = 1; i < magicCardsGridView.Rows[e.RowIndex].Cells.Count - 4; i++)
{
row[i] = ((TextBox)magicCardsGridView.Rows[e.RowIndex].Cells[i].Controls[0]).Text;
}
string filename = "";
FileUpload cardImage = (FileUpload)magicCardsGridView.Rows[e.RowIndex].FindControl("cardImageFileUpload");
if (cardImage.PostedFile.FileName != "")
{
filename = Path.GetFileName(cardImage.FileName);
cardImage.PostedFile.SaveAs(Server.MapPath(filename));
}
CardType card = new CardType(row[1].ToString(), row[2].ToString(), int.Parse(row[3].ToString()), 1, filename);
cardsService = new CardsService(card);
int rowUpdated;
string cardName = row["cardName"].ToString();
if (cardName.Length != 0)
{
if (!cardsService.CardAlreadyExists(cardIds, cardName))
{
rowUpdated = cardsService.UpdateTableRow(int.Parse(row[0].ToString()));
}
else
{
Response.Write("<script>alert('name already taken');</script>");
}
}
else
{
Response.Write("<script>alert('name can't be empty');</script>");
}
magicCardsGridView.EditIndex = -1;
magicCardsGridView.DataSource = cardsService.GetAllCards();
magicCardsGridView.DataBind();
}
public async Task CheckGettingActiveAndExpiredCardsAsync()
{
ApplicationDbContext db = GetDb();
var repository = new EfDeletableEntityRepository <Card>(db);
var typeCardRespository = new EfDeletableEntityRepository <TypeCard>(db);
var service = new CardsService(
typeCardRespository,
repository);
var firstUser = new ApplicationUser()
{
Id = "1",
};
var secondUser = new ApplicationUser()
{
Id = "1",
};
var typeCard = new TypeCard()
{
Id = "1",
Price = 50,
Name = "Week",
};
await db.TypeCards.AddAsync(typeCard);
await db.SaveChangesAsync();
await service.CreateCardAsync(firstUser.Id, typeCard.Price);
await service.CreateCardAsync(secondUser.Id, typeCard.Price);
var activeCards = await service.GetActiveCardsAsync <TestCardModel>();
var expiredCards = await service.GetExpiredCardsAsync <TestCardModel>();
Assert.Equal(2, activeCards.Count());
Assert.Empty(expiredCards);
}
public async Task AddVisitsToUserShouldThrow(string userId)
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Card>(db);
var user = new ApplicationUser();
await repository.AddAsync(new Card()
{
User = user,
UserId = user.Id,
});
await repository.SaveChangesAsync();
var service = new CardsService(repository, this.qrcodeService.Object, this.notificationsService.Object);
await Assert.ThrowsAnyAsync <NullReferenceException>(async() => await service.AddVisitsToUser(userId, 12));
}
public List<Dictionary<string, object>> Get(int? id = null, string nome = null, bool card = true)
{
Dictionary<string, object> parametros = new Dictionary<string, object>();
parametros.Add("id", id);
parametros.Add("nome", nome);
List<Dictionary<string, object>> listas = DBQuery("Lista_Select", parametros, CommandType.StoredProcedure);
CardsService cardService = new CardsService();
if (card)
{
foreach (Dictionary<string, object> lista in listas)
{
lista.Add("cards", cardService.Get(null, null, (int)lista["id"]));
}
}
return listas;
}
public ActionResult Login(LoginViewModel loginViewModel)
{
if (ModelState.IsValid)
{
if (CardsService.CardExists(loginViewModel.CardID, loginViewModel.PinCode))
{
var authorizationObject = AuthorizationService.GetAuthorizationObject(loginViewModel.CardID);
var authorizationObjectSerialized = JsonConvert.SerializeObject(authorizationObject);
FormsAuthentication.SetAuthCookie(authorizationObject.CardId, false);
var authTicket = new FormsAuthenticationTicket(1, authorizationObject.CardId, DateTime.Now,
DateTime.Now.AddMinutes(20),
false, authorizationObjectSerialized);
string encryptedTicket = FormsAuthentication.Encrypt(authTicket);
var authCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket);
HttpContext.Response.Cookies.Add(authCookie);
return(RedirectToAction("Index", "Home"));
}
}
ModelState.AddModelError("", "Invalid card number or pin code");
return(View(loginViewModel));
}
public List <Dictionary <string, object> > Get(int?id = null, string nome = null, bool card = true)
{
Dictionary <string, object> parametros = new Dictionary <string, object>();
parametros.Add("id", id);
parametros.Add("nome", nome);
List <Dictionary <string, object> > listas = DBQuery("Lista_Select", parametros, CommandType.StoredProcedure);
CardsService cardService = new CardsService();
if (card)
{
foreach (Dictionary <string, object> lista in listas)
{
lista.Add("cards", cardService.Get(null, null, (int)lista["id"]));
}
}
return(listas);
}
public async Task RemoveVisitsShouldRemoveExactlyOneVisit()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Card>(db);
var user = new ApplicationUser();
var newCard = new Card()
{
User = user,
UserId = user.Id,
Visits = 20,
};
await repository.AddAsync(newCard);
await repository.SaveChangesAsync();
var service = new CardsService(repository, this.qrcodeService.Object, this.notificationsService.Object);
var result = await service.RemoveVisitFromCard(newCard.Id);
Assert.Equal(19, result.Visits);
}
public async Task GetCardViewModelAsyncShouldReturnCorrectModel()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Card>(db);
var user = new ApplicationUser();
await repository.AddAsync(new Card()
{
User = user,
UserId = user.Id,
});
await repository.SaveChangesAsync();
var service = new CardsService(repository, this.qrcodeService.Object, this.notificationsService.Object);
var result = await service.GetCardViewModelAsync <TestCardModel>(user.Id);
Assert.Equal(user.CardId, result.Id);
Assert.Equal(0, result.Visits);
}
public ActionResult Registration(RegistrationViewModel registrationViewModel)
{
string messageRegistration = string.Empty;
if (ModelState.IsValid)
{
if (!CardsService.CardExists(registrationViewModel.CardID))
{
ClientsService.CreateClient(registrationViewModel.ConvertToClient());
TempData["statusRegistration"] = true;
return(RedirectToAction("Login"));
}
else
{
ModelState.AddModelError("", "Card already exists");
}
}
else
{
ModelState.AddModelError("", "Something wrong");
}
ViewBag.Message = messageRegistration;
return(View(registrationViewModel));
}
public async Task AddVisitsToUserShouldWorkCorrectly()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString()).Options;
var db = new ApplicationDbContext(options);
var repository = new EfDeletableEntityRepository <Card>(db);
var user = new ApplicationUser();
await repository.AddAsync(new Card()
{
User = user,
UserId = user.Id,
});
await repository.SaveChangesAsync();
var service = new CardsService(repository, this.qrcodeService.Object, this.notificationsService.Object);
var result = await service.AddVisitsToUser(user.Id, 12);
var result2 = await service.AddVisitsToUser(user.Id, 12);
Assert.Equal(12, result.Visits);
Assert.Equal(12, result2.Visits);
}
public CardsController()
{
service = new CardsService();
}
