public GameViewModel(CardViewModel currentCardViewModel, CardViewModel previewCardViewModel)
{
CurrentCardView = currentCardViewModel;
PreviewCardView = previewCardViewModel;
IsAnswerWrong = false;
EventManager.RegisterClassHandler(typeof(Control), UIElement.KeyDownEvent, new RoutedEventHandler(KeyDown));
}
public DeckEditorPreviewControl()
{
Game = new Game() { Name = "No Game Selected", CardBack = "pack://application:,,,/Resources/Back.jpg" };
Card = new CardViewModel();
//Card = new CardViewModel(new Card() { ImageUri = "pack://application:,,,/Resources/Back.jpg" });
InitializeComponent();
}
void OnNewCard(SKDCard newCard)
{
var condition = newCard.IsInStopList ? (Func<CardViewModel, bool>)(x => x.IsDeactivatedRootItem) : x => x.IsOrganisation && x.Organisation.UID == newCard.OrganisationUID;
var rootItem = RootItems.FirstOrDefault(condition);
if (rootItem == null)
{
if (newCard.IsInStopList)
RootItems.Add(CardViewModel.DeactivatedRootItem);
else
{
var organisation = OrganisationHelper.GetSingle(newCard.OrganisationUID);
if (organisation == null)
return;
rootItem = new CardViewModel(organisation);
RootItems.Add(rootItem);
}
}
var cards = rootItem.Children;
var cardViewModel = cards.FirstOrDefault(x => x.Card.UID == newCard.UID);
if (cardViewModel != null)
cardViewModel.Update(newCard);
else
rootItem.AddChild(new CardViewModel(newCard));
if (!newCard.IsInStopList)
{
var deactivatedRoot = RootItems.FirstOrDefault(x => x.IsDeactivatedRootItem);
if (deactivatedRoot != null)
{
var blockedCard = deactivatedRoot.Children.FirstOrDefault(x => x.Card.UID == newCard.UID);
if (blockedCard != null)
deactivatedRoot.RemoveChild(blockedCard);
}
}
rootItem.IsExpanded = true;
RootItems = new ObservableCollection<CardViewModel>(RootItems.OrderBy(x => x.IsDeactivatedRootItem));
OnPropertyChanged(() => RootItems);
OnPropertyChanged(() => RootItemsArray);
}
public CardControl(CardViewModel viewModel)
{
ViewModel = viewModel;
InitializeComponent();
}
private void OpenEmptyCard()
{
card.Dispose();
card = new CardViewModel(a[5], true);
}
bool CanDoRevealCard(CardViewModel card)
{
return(card.HasInGamePosition && !card.IsRevealed);
}
public CardPageView()
{
InitializeComponent();
DataContext = new CardViewModel();
}
public async Task <CardViewModel> PostAsync([FromBody] CardViewModel value)
{
return(mapper.Map <CardViewModel>(await Service.CreateAsync(mapper.Map <ICard>(value))));
}
private string GetBackImagePath(Card card)
{
var viewModel = new CardViewModel(card);
return (!string.IsNullOrEmpty(viewModel.ImagePath2)) ?
viewModel.ImagePath2
: null;
}
public void PerformUIPlayerAction(ActionType actionType, CardViewModel card, PileViewModel pile)
{
this.uiRequestAction = new PlayerAction();
this.uiRequestAction.ActionType = actionType;
this.uiRequestAction.Card = card != null ? card.CardModel : null;
this.uiRequestAction.Pile = pile != null ? pile.PileModel : null;
this.state = ClientState.WaitingForOpponent;
this.uiPlayerActionWaitHandle.Set();
}
public BlBackupAmp(LibraryData sys, CardViewModel card)
: base(sys, card)
{
}
public ActionResult RemoveCard(CardViewModel card)
{
this.cardService.DeleteCard(card.CardID);
return(this.Redirect("AllCards"));
}
public DarkBarImageBuilder(ThemeConfig config, CardViewModel card, string dir) : base(config, card, dir)
{
}
private IEnumerable <CardViewModel> ReadSmartCards()
{
var result = new List <CardViewModel>();
var smartCardCerts = new List <X509Certificate2>();
var myStore = new X509Store(StoreName.My, StoreLocation.CurrentUser);
myStore.Open(OpenFlags.ReadOnly);
foreach (X509Certificate2 cert in myStore.Certificates)
{
try
{
if (!cert.HasPrivateKey)
{
continue; // not smartcard for sure
}
if (string.IsNullOrEmpty(cert.FriendlyName))
{
continue;
}
if (cert.PrivateKey is RSACryptoServiceProvider)
{
var rsa = cert.PrivateKey as RSACryptoServiceProvider;
if (rsa == null)
{
continue; // not smart card cert again
}
if (rsa.CspKeyContainerInfo.HardwareDevice) // sure - smartcard
{
// inspect rsa.CspKeyContainerInfo.KeyContainerName Property
// or rsa.CspKeyContainerInfo.ProviderName (your smartcard provider, such as
// "Schlumberger Cryptographic Service Provider" for Schlumberger Cryptoflex 4K
// card, etc
Console.WriteLine(cert.FriendlyName);
Console.WriteLine(cert.SerialNumber);
Console.WriteLine(cert.Issuer);
var item = new CardViewModel();
item.FriendlyName = cert.FriendlyName;
item.SerialNumber = cert.SerialNumber;
item.Issuer = cert.Issuer;
result.Add(item);
//rsa.SignData(); // to confirm presence of private key - to finally authenticate
}
}
}
catch (Exception ex)
{
var item = new CardViewModel();
item.FriendlyName = ex.StackTrace;
item.SerialNumber = "No acceso";
item.Issuer = "No acceso";
result.Add(item);
Console.WriteLine("Fallo");
continue;
}
}
myStore.Close();
return(result);
//vM.FriendlyName = "NO Existen certificados";
}
public AlertPage()
{
InitializeComponent();
BindingContext = new CardViewModel();
}
public static CardBarImageBuilder GetBarImageBuilder(CardViewModel card)
{
var buildType = CurrentTheme.BuildType ?? typeof(DefaultBarImageBuilder);
return((CardBarImageBuilder)Activator.CreateInstance(buildType, Config, card, CurrentTheme.Directory));
}
public void HandleMessage(NetworkMessage message)
{
lock (this.messageLock)
{
if (message.MessageCategory == SystemMessages.SystemPrefix)
{
switch (message.MessageType)
{
case SystemMessages.Authenticate:
{
AuthenticationInfo auth = NetworkSerializer.Deserialize<AuthenticationInfo>(message.MessageContent);
this.username = auth.Username;
}
break;
case SystemMessages.ProposeGame:
{
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
GameSpecificationInfo gameSpecification = NetworkSerializer.Deserialize<GameSpecificationInfo>(message.MessageContent);
this.gameLobbyModel.ServerProposeGame(gameSpecification);
}));
}
break;
case SystemMessages.CancelRequest:
{
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
this.gameLobbyModel.ServerCancelGame();
}));
}
break;
case SystemMessages.GameStarted:
{
this.gameStartEvent.Reset();
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
this.gameLobbyModel.OnServerGameStarted();
}));
this.gameStartEvent.WaitOne();
}
break;
case SystemMessages.SendUsers:
{
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
UserInfo userInfo = NetworkSerializer.Deserialize<UserInfo>(message.MessageContent);
this.gameLobbyModel.Users.Clear();
for (int i = 0; i < userInfo.Users.Count; i++)
{
this.gameLobbyModel.Users.Add(userInfo.Users[i]);
}
}));
}
break;
case SystemMessages.AddUser:
{
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
AddRemoveUserInfo userInfo = NetworkSerializer.Deserialize<AddRemoveUserInfo>(message.MessageContent);
this.gameLobbyModel.Users.Add(userInfo.User);
}));
}
break;
case SystemMessages.RemoveUser:
{
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
AddRemoveUserInfo userInfo = NetworkSerializer.Deserialize<AddRemoveUserInfo>(message.MessageContent);
this.gameLobbyModel.Users.Remove(userInfo.User);
}));
}
break;
case SystemMessages.SendLobbies:
{
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
LobbyInfo lobbyInfo = NetworkSerializer.Deserialize<LobbyInfo>(message.MessageContent);
this.gameLobbyModel.LobbyName = lobbyInfo.Lobbies[0];
for (int i = 0; i < lobbyInfo.Lobbies.Count; i++)
{
this.gameLobbyModel.Lobbies.Add(lobbyInfo.Lobbies[i]);
}
// enter default lobby
NetworkMessage enterLobbyMessage = new NetworkMessage();
enterLobbyMessage.MessageCategory = SystemMessages.SystemPrefix;
enterLobbyMessage.MessageType = SystemMessages.EnterLobby;
EnterLobbyInfo enterLobby = new EnterLobbyInfo();
enterLobby.Lobby = lobbyInfo.Lobbies[0];
enterLobbyMessage.MessageContent = NetworkSerializer.Serialize(enterLobby);
this.SendSystemMessage(enterLobbyMessage);
}));
}
break;
case SystemMessages.SendChat:
{
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
ChatInfo chatInfo = NetworkSerializer.Deserialize<ChatInfo>(message.MessageContent);
// does this need to split by '\n'?
this.gameLobbyModel.Chat.Add(chatInfo.Chat);
}));
}
break;
}
}
else if(message.MessageCategory == GameMessages.GamePrefix)
{
switch (message.MessageType)
{
case GameMessages.GameEnded:
{
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
this.gameViewModel.GameModel.GameOver = true;
}));
}
break;
case GameMessages.TurnEnded:
{
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
this.gameViewModel.FireTurnEnded();
}));
}
break;
case GameMessages.RequestAction:
{
if (!initialized)
{
initialized = true;
}
PlayerAction action = this.gameViewModel.RequestUIPlayerAction();
NetworkMessage actionMessage = new NetworkMessage();
actionMessage.MessageCategory = GameMessages.GamePrefix;
switch (action.ActionType)
{
case ActionType.PlayCard:
actionMessage.MessageType = GameMessages.PlayCard;
actionMessage.MessageContent = NetworkSerializer.Serialize(new ActionCardInfo() { Card = action.Card.ID });
this.SendGameMessage(actionMessage);
break;
case ActionType.PlayBasicTreasures:
actionMessage.MessageType = GameMessages.PlayBasicTreasure;
this.SendGameMessage(actionMessage);
break;
case ActionType.EnterBuyPhase:
actionMessage.MessageType = GameMessages.BuyPhase;
this.SendGameMessage(actionMessage);
break;
case ActionType.BuyCard:
actionMessage.MessageType = GameMessages.BuyCard;
actionMessage.MessageContent = NetworkSerializer.Serialize(new ActionCardInfo() { Card = action.Pile.Card.ID });
this.SendGameMessage(actionMessage);
break;
case ActionType.EndTurn:
actionMessage.MessageType = GameMessages.EndTurn;
this.SendGameMessage(actionMessage);
break;
case ActionType.CleanupCard:
actionMessage.MessageType = GameMessages.CleanupCard;
actionMessage.MessageContent = NetworkSerializer.Serialize(new ActionCardInfo() { Card = action.Card.ID });
this.SendGameMessage(actionMessage);
break;
case ActionType.PlayCoinTokens:
actionMessage.MessageType = GameMessages.PlayCoinTokens;
this.SendGameMessage(actionMessage);
break;
}
}
break;
case GameMessages.RequestChoice:
{
RequestChoiceInfo choiceInfo = NetworkSerializer.Deserialize<RequestChoiceInfo>(message.MessageContent);
string choiceText = choiceInfo.ChoiceText;
string choiceType = choiceInfo.ChoiceType;
bool order = false;
if (choiceType == "ORDER")
{
choiceType = "CARD";
order = true;
}
if (choiceType == "CARD" || choiceType == "PILE")
{
PlayerChoiceParameters parameters = new PlayerChoiceParameters();
parameters.MinChoices = choiceInfo.MinChoices;
parameters.MaxChoices = choiceInfo.MaxChoices;
ChoiceSource source = (ChoiceSource)Enum.Parse(typeof(ChoiceSource), choiceInfo.ChoiceSource, true);
parameters.Source = source;
parameters.Order = order;
if (choiceType == "CARD")
{
parameters.SourceType = ChoiceSourceType.Card;
List<CardViewModel> potential = new List<CardViewModel>();
List<CardViewModel> cardChoices = new List<CardViewModel>();
if ((source & ChoiceSource.FromHand) != 0)
{
potential.AddRange(this.Player.Hand);
}
if ((source & ChoiceSource.FromPile) != 0)
{
potential.AddRange(this.gameViewModel.Piles.Select(p => p.TopCard));
}
if ((source & ChoiceSource.FromTrash) != 0)
{
potential.AddRange(this.gameViewModel.Trash);
}
if ((source & ChoiceSource.InPlay) != 0)
{
potential.AddRange(this.Player.Played);
}
foreach(string c in choiceInfo.Choices)
{
CardViewModel cvm = potential.FirstOrDefault(card => card.ID == c);
if (cvm == null && (source & ChoiceSource.None) != 0)
{
cvm = new CardViewModel(CardModelFactory.GetCardModel(c));
}
potential.Remove(cvm);
cardChoices.Add(cvm);
}
parameters.CardChoices = cardChoices;
}
else
{
parameters.SourceType = ChoiceSourceType.Pile;
List<PileViewModel> pileChoices = new List<PileViewModel>();
foreach (string c in choiceInfo.Choices)
{
pileChoices.Add(this.gameViewModel.Piles.First(p => p.Card.ID == c));
}
parameters.PileChoices = pileChoices;
}
parameters.ChoiceText = choiceText;
PlayerChoice choice = this.gameViewModel.RequestUIPlayerChoice(parameters);
NetworkMessage makeChoiceMessage = new NetworkMessage();
makeChoiceMessage.MessageCategory = GameMessages.GamePrefix;
makeChoiceMessage.MessageType = GameMessages.MakeChoice;
ChoiceInfo makeChoiceInfo = new ChoiceInfo();
if (choiceType == "CARD")
{
makeChoiceInfo.Choices = choice.ChosenCards.Select(c => c.ID).ToList();
}
else
{
makeChoiceInfo.Choices = choice.ChosenPiles.Select(p => p.ID).ToList();
}
makeChoiceMessage.MessageContent = NetworkSerializer.Serialize(makeChoiceInfo);
this.SendGameMessage(makeChoiceMessage);
}
else
{
Debug.Assert(choiceType == "EFFECT");
PlayerChoiceParameters parameters = new PlayerChoiceParameters();
parameters.MinChoices = choiceInfo.MinChoices;
parameters.MaxChoices = choiceInfo.MaxChoices;
parameters.ChoiceText = choiceText;
parameters.SourceType = ChoiceSourceType.Effect;
List<EffectViewModel> effectChoices = new List<EffectViewModel>();
for (int i = 0; i < choiceInfo.Choices.Count;i++)
{
effectChoices.Add(new EffectViewModel(choiceInfo.Choices[i], choiceInfo.ChoiceDescriptions[i]));
}
parameters.EffectChoices = effectChoices;
PlayerChoice playerChoice = this.gameViewModel.RequestUIPlayerChoice(parameters);
NetworkMessage makeChoiceMessage = new NetworkMessage();
makeChoiceMessage.MessageCategory = GameMessages.GamePrefix;
makeChoiceMessage.MessageType = GameMessages.MakeChoice;
ChoiceInfo makeChoiceInfo = new ChoiceInfo();
makeChoiceInfo.Choices = playerChoice.ChosenEffects.Select(e => e.Choice).ToList();
makeChoiceMessage.MessageContent = NetworkSerializer.Serialize(makeChoiceInfo);
this.SendGameMessage(makeChoiceMessage);
}
}
break;
case GameMessages.SupplyPileInfo:
case GameMessages.ExtraPileInfo:
{
synchronizer.HandleClientStateMessage(message);
}
break;
case GameMessages.PlayerInfo:
{
synchronizer.HandleClientStateMessage(message);
}
break;
case GameMessages.PlayerState:
case GameMessages.PileState:
case GameMessages.CardPileState:
{
synchronizer.HandleClientStateMessage(message);
}
break;
case GameMessages.GameState:
{
synchronizer.HandleClientStateMessage(message);
}
break;
case GameMessages.Log:
{
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
LogInfo logInfo = NetworkSerializer.Deserialize<LogInfo>(message.MessageContent);
this.gameViewModel.GameModel.TextLog.WriteLine(logInfo.Log);
}));
}
break;
case GameMessages.StartTurn:
{
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
this.gameViewModel.GameModel.StartTurn();
}));
}
break;
case GameMessages.SetupComplete:
{
ViewModelDispatcher.BeginInvoke(new Action(delegate()
{
this.gameViewModel.OnInitialized();
this.gameViewModel.GameInitialized += gameViewModel_GameInitialized;
}));
}
break;
}
}
}
}
/// <summary>
/// Init View and create/assign our ViewModel
/// </summary>
public CardView()
{
InitializeComponent();
ViewModel = new CardViewModel();
}
public void GatherCardDetails(CardViewModel cardViewModel)
{
cardViewModel.StartDate = StartDateTextField.Text;
cardViewModel.IssueNumber = IssueNumberTextField.Text;
}
void OnOrganisationUsersChanged(Organisation newOrganisation)
{
if (newOrganisation.UserUIDs.Any(x => x == ClientManager.CurrentUser.UID))
{
if (!RootItems.Any(x => x.IsOrganisation && x.Organisation.UID == newOrganisation.UID))
{
var organisationViewModel = new CardViewModel(newOrganisation);
var cardFilter = new CardFilter();
cardFilter.EmployeeFilter = new EmployeeFilter { OrganisationUIDs = new System.Collections.Generic.List<Guid> { newOrganisation.UID } };
var cards = CardHelper.Get(cardFilter);
if (cards == null || cards.Count() == 0)
return;
RootItems.Add(organisationViewModel);
foreach (var card in cards.Where(x => x.OrganisationUID == newOrganisation.UID))
{
organisationViewModel.AddChild(new CardViewModel(card));
}
OnPropertyChanged(() => RootItems);
OnPropertyChanged(() => RootItemsArray);
}
}
else
{
var organisationViewModel = RootItems.FirstOrDefault(x => x.IsOrganisation && x.Organisation.UID == newOrganisation.UID);
if (organisationViewModel != null)
{
RootItems.Remove(organisationViewModel);
OnPropertyChanged(() => RootItems);
OnPropertyChanged(() => RootItemsArray);
}
}
}
public ActionResult Create(CustomerIsssueCard model, List <int> CardsId)
{
var ts = (TravelSession)Session["TravelSessionInfo"];
for (int i = 0; i < CardsId.Count; i++)
{
model.CardId = CardsId[i];
//model.CreatedBy = ts.AppUserId;
model.CustomerID = model.HFCustomerID;
}
//model.CreatedBy = ts.AppUserId;
model.Created = DateTime.Now;
model.ProductId = 2;
//model.CustomerTypeId =1;
model.CustomerTpeName = _GenPro.GetCustomerType(model.CustomerTypeId);
model.AgentId = 2;
model.Gender = "male";
//long CustomerID = _Custrepo.GetCustomerID();
bool flag;
flag = _Custrepo.CheckDuplicateUsername(model.CustomerCode);
if (flag == true)
{ //_Custrepo.UpdateCard(model);
long CID = _Custrepo.CreateCard(model);
model.CustomerID = CID;
_Custrepo.CreateCards(model);
}
else
{
model.AgentId = 2;
model.Gender = "male";
model.CustomerID = _Custrepo.GetCustomerID();
model.ProductId = 2;
model.UpdatedBy = ts.AppUserId;
//_Custrepo.CreateCard(model);
_Custrepo.UpdateCard(model);
_Custrepo.CreateCards(model);
}
CardViewModel cardmodel = new CardViewModel();
cardmodel.CardId = model.CardId;
cardmodel.CardStatusId = 3;
_Custrepo.UpdateCardToActiveStatus(cardmodel);
//// This IS for Active Status
//if (Selectedcardnumber != null) ////////// Checking if product is other than Ticketing
//{
// List<int> Selectedcardnumbers = new List<int>();
// foreach (int sid in Selectedcardnumber)
// {
// Selectedcardnumbers.Add(sid);
// }
// Add(Selectedcardnumbers,model.AgentId ,CustomerID);
// }
//////////// Return view //////////////
//ViewData["Country"] = new SelectList(_CountryRepo.HotelCountryList(), "CountryId", "CountryName");
CustomerIsssueCard models = new CustomerIsssueCard()
{
CountryList = _CountryRepo.GetAllCountryList().ToList(),
};
//ViewData["Agents"] = new SelectList(_issuecardrepo.ListAllAgent(), "AgentId", "AgentName", 0);
ViewData["success"] = "Record successfully added.";
return(RedirectToAction("Index", models));
}
public IViewComponentResult Invoke(CardViewModel model)
{
return(View(model));
}
public IActionResult Card(CardViewModel cardData)
{
var res = _paymentResolver[PaymentType.Visa].Process(GetPaymentInfo());
return(res);
}
public ItemBoughtEventArgs(CardViewModel purchasedCardID, PlayerViewModel purchasingPlayer)
{
this.PurchasedCard = purchasedCardID;
this.PurchasingPlayer = purchasingPlayer;
}
public async Task <IActionResult> Create(CardViewModel card)
{
await cardWebService.Create(card);
return(RedirectToAction("Details", "Wallet", new { id = card.WalletId }));
}
public ActionResult AddRequest(TravelRequest newTravelRequest, Postedcards postedcards, Card card)
{
try
{
CardViewModel newCardList = new CardViewModel();
newCardList = new AppClass().GetCardsModel(newTravelRequest.Accountdetails.AccountNo, postedcards);
newTravelRequest.Action = "New Request";
newTravelRequest.ApprovalStage = "Card Services Approval";
var InsertTravelRequest = new AppClass().postDBRequest(newTravelRequest, newCardList, "TravelConnection");
string[] result = InsertTravelRequest.ToString().Split('|');
if (result[0] != "0")
{
if (result[0] == "2627")
{
return(Content("Unable to Submit \n Duplicate record"));
}
else
{
TempData["ErrorMessage"] = result[1];
TempData["TravelRequest"] = newTravelRequest;
return(RedirectToAction("NewRequest"));
}
}
else
{
List <ApproverInfo> approversnames = new List <ApproverInfo>();
List <ApproverInfo> approvers = new List <ApproverInfo>();
approvers = new AppClass().getApproverInfo();
var approverNames = new AppClass().getApprovernames();
foreach (var approver in approvers)
{
SendEmail newmail = new SendEmail();
newmail.sendEmail(newTravelRequest.Accountdetails.Account_Name,
newTravelRequest.Accountdetails.AccountNo,
newTravelRequest.StaffProfile.StaffNo,
newTravelRequest.StaffProfile.StaffName,
newTravelRequest.StaffProfile.jobtitle,
newTravelRequest.Action,
newTravelRequest.Comment,
newTravelRequest.ApprovalStage,
newTravelRequest.Date_Submitted.ToString(),
approver.Email,
newTravelRequest.StaffProfile.StaffNo,
newTravelRequest.StaffProfile.StaffName);
}
TempData["Key"] = "Insert";
TempData["ErrorMessage"] = "You have successfully submitted your request for possible approval by:";
TempData["Approvernames"] = string.Join("\\n", approverNames);
TempData["TravelRequest"] = newTravelRequest;
return(RedirectToAction("AwaitingApproval"));
}
}
catch (Exception ex)
{
return(Content(ex.Message));
}
}
public ClassicBarImageBuilder(ThemeConfig config, CardViewModel card, string dir) : base(config, card, dir)
{
ImageOffset = FadeOffset = CreatedIconOffset = -19;
CostFontSize = 18;
CountFontSize = 16;
}
public async Task <bool> Put(CardViewModel value, [FromRoute] Guid id)
{
value.Id = id;
return(await Service.UpdateAsync(mapper.Map <ICard>(value)));
}
public async Task <ActionResult <CardViewModel> > Create([FromBody] CardViewModel cardToCreate)
{
await _service.CreateCardItemAsync(cardToCreate);
return(CreatedAtRoute("GetCard", new { id = cardToCreate.Id }, cardToCreate));
}
private void Open(IHrsHolder h)
{
card.Dispose();
card = new CardViewModel(h, true);
}
private bool CanAutoSelect(CardViewModel card)
{
return card != null && card.IsSelectable;
}
public Alternate(CardViewModel vm, string altName, int altIndex)
{
VM = vm;
Name = altName;
Index = altIndex;
}
private void MoveSelect(CardViewModel card)
{
Utils.WriteLine("MoveSelecting: {0}", card);
if (card == null)
{
ResetMoveAndRefresh();
return;
}
if (Tableau.FromCard == null)
{
Tableau.FromCard = card;
Refresh();
return;
}
Tableau.ToCard = card;
if (Tableau.FromCard.Column == Tableau.ToCard.Column)
{
ResetMoveAndRefresh();
return;
}
if (Tableau.TryMove())
{
AddCheckPoint();
ResetMoveAndRefresh();
return;
}
ResetMoveAndRefresh();
}
public IActionResult Index(string id = "")
{
var set = new Set();
var cards = new List <Card>();
if (id == "KLD" || id == "kld")
{
set = new Set()
{
name = "Kaladesh",
code = "KLD",
releaseDate = "2016-09-30"
};
using (StreamReader r = System.IO.File.OpenText(@"wwwroot/js/KLD.json"))
{
string json = r.ReadToEnd();
var cardDTO = JsonConvert.DeserializeObject <CardDTO>(json);
cards = cardDTO.Cards;
}
}
else
{
set = MTGAPI.GetSetBySetCode(id);
cards = MTGAPI.GetCardsBySetCode(id);
}
var lrSetReviewQuery = db.SetReviews
.Where(sr => sr.SetCode.Equals(id, StringComparison.OrdinalIgnoreCase))
.FirstOrDefault();
var lrSetReview = (lrSetReviewQuery == null) ? new List <Grade>() : lrSetReviewQuery.Grades;
var rarityFilter = new Dictionary <string, bool>()
{
{ "Common", false },
{ "Uncommon", false },
{ "Rare", false },
{ "Mythic Rare", false },
};
var colorFilter = new Dictionary <string, bool>()
{
{ "White", false },
{ "Blue", false },
{ "Black", false },
{ "Red", false },
{ "Green", false },
{ "Colorless", false }
};
cards = cards
.Where(c => !c.type.Contains("Basic Land"))
.OrderBy(c => c.number, new CardComparer())
.ToList();
var userGrades = new CardListViewModel();
foreach (var card in cards)
{
var cvm = new CardViewModel()
{
Card = card,
Grade = new Grade()
{
CardName = card.name,
MultiverseID = card.multiverseid ?? -1,
Value = GradeEnum.None
}
};
userGrades.CardViewModels.Add(cvm);
}
return(View(new SetViewModel()
{
RarityFilter = rarityFilter,
ColorFilter = colorFilter,
Set = set,
Cards = cards,
UserGrades = userGrades
}));
}
private (string, string, IReplyMarkup) CardToMediaDto(CardViewModel card) => (
$"{card.Header}\n{card.Content}",
private void AutoSelect(CardViewModel card)
{
Utils.WriteLine("Auto-selecting: {0}", card);
if (card.Column == -1 && card.Row == -1)
{
Deal();
ResetMoveAndRefresh();
return;
}
Tableau.FromCard = card;
int firstSpace = Tableau.FirstSpace;
if (firstSpace == -1)
{
ResetMoveAndRefresh();
return;
}
Tableau.ToCard = Tableau.Piles[firstSpace][0];
if (Tableau.TryMove())
{
AddCheckPoint();
ResetMoveAndRefresh();
return;
}
ResetMoveAndRefresh();
}
public async Task <IActionResult> Update(int TN, CardViewModel model)
{
var result = await _ICardRespositories.Update(TN, model);
return(Ok(result));
}
private bool CanMoveSelect(CardViewModel card)
{
return card != null && card.IsMoveSelectable;
}
public void Register(CardViewModel CardViewModel)
{
var registerCommand = _mapper.Map <RegisterNewCardCommand>(CardViewModel);
Bus.SendCommand(registerCommand);
}
public Alternate(CardViewModel vm, string altName, int altIndex)
{
VM = vm;
Name = altName;
Index = altIndex;
}
public void Update(CardViewModel CardViewModel)
{
var updateCommand = _mapper.Map <UpdateCardCommand>(CardViewModel);
Bus.SendCommand(updateCommand);
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
ViewModel = (CardViewModel)e.Parameter;
}
private string GetFrontImagePath(Card card)
{
var viewModel = new CardViewModel(card);
return (!string.IsNullOrEmpty(viewModel.ImagePath1)) ?
viewModel.ImagePath1
: viewModel.ImagePath;
}
