public static CardDTO ToCardDTO(this Card card)
{
CardDTO newCardDTO = new CardDTO
{
Id = card.Id,
BoardId = card?.CardsList.BoardId,
CardsListId = card.CardsListId,
Discriminator = card.Discriminator,
ItemNumber = card?.ItemNumber,
Title = card.Title,
Description = card.Description,
Start = card.Start,
End = card.End,
Duration = card?.Duration,
Complexity = card?.Complexity
};
if (card.Discriminator == "PlanCard")
{
PlanCardDTO planCardDTO = (PlanCardDTO)newCardDTO;
planCardDTO.IsDone = ((PlanCard)card).IsDone;
planCardDTO.DoneUserId = ((PlanCard)card).DoneUserId;
planCardDTO.DoneUser = ((PlanCard)card).DoneUser.ToUserDTO();
return(planCardDTO);
}
else
{
HabitCardDTO habitCardDTO = (HabitCardDTO)newCardDTO;
habitCardDTO.DoneCounter = ((HabitCard)card).DoneCounter;
habitCardDTO.NotDoneCounter = ((HabitCard)card).NotDoneCounter;
return(habitCardDTO);
}
}
public Fee(ResourceManager rm, CardDTO card = null, string accountNo = null)
{
this.accountNo = accountNo;
this.card = card;
this.rm = rm;
InitializeComponent();
}
public void Test_Idempotency_PayinsCardDirectCreate()
{
string key = DateTime.Now.Ticks.ToString();
UserNaturalDTO john = this.GetJohn();
WalletPostDTO wallet =
new WalletPostDTO(new List <string> {
john.Id
}, "WALLET IN EUR WITH MONEY", CurrencyIso.EUR);
var johnsWallet = this.Api.Wallets.Create(wallet);
CardRegistrationPostDTO cardRegistrationPost =
new CardRegistrationPostDTO(johnsWallet.Owners[0], CurrencyIso.EUR);
CardRegistrationDTO cardRegistration = this.Api.CardRegistrations.Create(cardRegistrationPost);
CardRegistrationPutDTO cardRegistrationPut = new CardRegistrationPutDTO();
cardRegistrationPut.RegistrationData = this.GetPaylineCorrectRegistartionData(cardRegistration);
cardRegistration = this.Api.CardRegistrations.Update(cardRegistrationPut, cardRegistration.Id);
CardDTO card = this.Api.Cards.Get(cardRegistration.CardId);
PayInCardDirectPostDTO payIn = new PayInCardDirectPostDTO(cardRegistration.UserId, cardRegistration.UserId,
new Money {
Amount = 1000, Currency = CurrencyIso.EUR
},
new Money {
Amount = 0, Currency = CurrencyIso.EUR
},
johnsWallet.Id, "http://test.com", card.Id);
payIn.CardType = card.CardType;
Api.PayIns.CreateCardDirect(key, payIn);
var result = Api.Idempotency.Get(key);
Assert.IsInstanceOf <PayInCardDirectDTO>(result.Resource);
}
private float m_fGasStoreGasDOTotal; //total gasDO in store
public DataTransfer()
{
m_iResponseCode = RESPONSE_CODE_NONE;
m_stResponseErrorMsg = "";
m_stResponseErrorMsgDetail = "";
m_stResponseDataString = "";
m_bResponseDataBool = false;
m_dtoResponseDataCustomerDTO = null;
m_dtoResponseDataCardDTO = null;
m_dtoResponseDataGasStationDTO = null;
m_dtoResponseDataRechargeDTO = null;
m_dtoResponseDataSaleGasDTO = null;
m_dtoResponseDataSystemAdminDTO = null;
m_dtoResponseDataGasStoreDTO = null;
m_dtoResponseDataGasStoreUpdateDTO = null;
m_dsResponseDataSet = null;
m_iCurrentPriceGas92 = 0;
m_iCurrentPriceGas95 = 0;
m_iCurrentPriceGasDO = 0;
m_fGasStoreGas92Total = 0;
m_fGasStoreGas95Total = 0;
m_fGasStoreGasDOTotal = 0;
}
public async Task UpdateCard_UnknownIdPassed_ReturnsNotFound()
{
// Arrange
var controller = new CardsController(flashcardDbContextMock.Object, logger);
int unknownId = 15;
var rightCard = new CardDTO
{
Id = 15,
Type = "Teszt tipus update",
Card_number = 3,
Question_text = "Teszt kartya kerdes",
Question_picture = "kep.jpg",
Answer_text = "Teszt kartya valasz",
Answer_picture = "kep2.jpg",
Deck = new DeckInfoDTO
{
Id = 1,
Name = "Teszt csomag",
Module = Module.A,
Deck_number = 1,
Status = DeckStatus.Approved
}
};
// Act
var result = await controller.UpdateCard(unknownId, rightCard);
// Asssert
Assert.IsType <NotFoundResult>(result);
}
public async Task <CardDTO> ChangeCardAsync(CardDTO cardDTO)
{
var card = db.Cards.FirstOrDefault(c => c.Id == cardDTO.Id);
if (card == null)
{
throw new Exception("Card is not exist!");
}
card.CardsListId = cardDTO.CardsListId;
card.ItemNumber = cardDTO.ItemNumber;
card.Title = cardDTO.Title;
card.Description = cardDTO.Description;
card.Start = cardDTO.Start;
card.End = cardDTO.End;
card.Duration = cardDTO.Duration;
if (cardDTO.Discriminator == "PlanCard")
{
PlanCard planCard = ((PlanCard)card);
if (planCard.IsDone != (planCard.DoneUserId != null))
{
throw new Exception("Error!");
}
planCard.IsDone = ((PlanCardDTO)cardDTO).IsDone;
planCard.DoneUserId = ((PlanCardDTO)cardDTO).DoneUserId;
}
if (cardDTO.Discriminator == "HabitCard")
{
((HabitCard)card).DoneCounter = ((HabitCardDTO)cardDTO).DoneCounter;
((HabitCard)card).NotDoneCounter = ((HabitCardDTO)cardDTO).NotDoneCounter;
}
await db.SaveChangesAsync();
return(db.Cards.FirstOrDefault(c => c.Id == cardDTO.Id).ToCardDTO());
}
public async Task <ActionResult <CardDTO> > PostCard(int listId, CardDTO data)
{
var card = await _context.Cards.FindAsync(data.Id);
if (card != null)
{
var err = new ValidationErrors().Add("Card already in use", nameof(card.Name));
return(BadRequest(err));
}
var newCard = new Card()
{
Name = data.Name,
AuthorId = data.AuthorId,
ListId = listId
};
_context.Cards.Add(newCard);
var res = await _context.SaveChangesAsyncWithValidation();
if (!res.IsEmpty)
{
return(BadRequest(res));
}
return(CreatedAtAction(nameof(GetOne), new { name = newCard.Name }, newCard.ToDTO()));
}
public async Task <ActionResult <CardDTO> > CreateCard([FromBody] CardDTO cardDTO)
{
if (!ModelState.IsValid)
{
_logger.LogError("ModelState is invalid in the CreateCard() method");
return(BadRequest(ModelState));
}
var card = new Card
{
Type = cardDTO.Type,
Card_number = cardDTO.Card_number,
Question_text = cardDTO.Question_text,
Question_picture = cardDTO.Question_picture,
Answer_text = cardDTO.Answer_text,
Answer_picture = cardDTO.Answer_picture,
DeckId = cardDTO.Deck.Id
};
_context.Cards.Add(card);
await _context.SaveChangesAsync();
_logger.LogInformation("Creating card in the CreateCard() method");
return(CreatedAtAction(nameof(GetCard), new { id = card.Id }, card));
}
public async Task <IActionResult> UpdateCard([FromRoute] int id, [FromBody] CardDTO cardDTO)
{
if (!ModelState.IsValid)
{
_logger.LogError("ModelState is invalid in the UpdateCard() method");
return(BadRequest(ModelState));
}
var card = await _context.Cards.FindAsync(id);
if (card == null)
{
_logger.LogWarning("Card not found in the UpdateCard({0}) method", id);
return(NotFound());
}
card.Type = cardDTO.Type;
card.Answer_text = cardDTO.Answer_text;
card.Answer_picture = cardDTO.Answer_picture;
card.Question_text = cardDTO.Question_text;
card.Question_picture = cardDTO.Question_picture;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException) when(!CardExists(id))
{
return(NotFound());
}
_logger.LogInformation("Updating card in the UpdateCard({0}) method", id);
return(NoContent());
}
public DataTransfer UpdateSaleGas(CardDTO dtoCard)
{
DataTransfer dataResult = new DataTransfer();
bool result = true;
try
{
string query = string.Format("UPDATE CARD SET CARD_MONEY = @CARD_MONEY, CARD_MONEY_EX = CARD_MONEY_EX + @CARD_MONEY_EX WHERE CARD_ID = @CARD_ID");
SqlParameter[] sqlParameters = new SqlParameter[3];
sqlParameters[0] = new SqlParameter("@CARD_ID", SqlDbType.NVarChar);
sqlParameters[0].Value = Convert.ToString(dtoCard.CardID);
sqlParameters[1] = new SqlParameter("@CARD_MONEY", SqlDbType.Int);
sqlParameters[1].Value = Convert.ToInt32(dtoCard.CardRemainingMoney);
sqlParameters[2] = new SqlParameter("@CARD_MONEY_EX", SqlDbType.Int);
sqlParameters[2].Value = Convert.ToInt32(dtoCard.CardMoneyEx);
result = m_dbConnection.ExecuteUpdateQuery(query, sqlParameters);
}
catch (Exception ex)
{
result = false;
dataResult.ResponseErrorMsgDetail = ex.Message + " : " + ex.StackTrace;
}
if (result)
{
dataResult.ResponseCode = DataTransfer.RESPONSE_CODE_SUCCESS;
}
else
{
dataResult.ResponseCode = DataTransfer.RESPONSE_CODE_FAIL;
dataResult.ResponseErrorMsg = 2 + SGMText.CARD_INSERT_ERR;
}
return(dataResult);
}
public CardDTO GetCard(string stCardID)
{
CardDTO dtoCard = null;
string query = string.Format("SELECT * FROM CARD WHERE CARD_ID = @CARD_ID");
SqlParameter[] sqlParameters = new SqlParameter[1];
sqlParameters[0] = new SqlParameter("@CARD_ID", SqlDbType.NVarChar);
sqlParameters[0].Value = Convert.ToString(stCardID);
DataTable tblResult = m_dbConnection.ExecuteSelectQuery(query, sqlParameters);
if (tblResult.Rows.Count > 0)
{
dtoCard = new CardDTO();
foreach (DataRow dr in tblResult.Rows)
{
dtoCard.CardID = dr["CARD_ID"].ToString();;
dtoCard.CardUnlockState = Boolean.Parse(dr["CARD_STATE"].ToString());
dtoCard.CardRemainingMoney = Int32.Parse(dr["CARD_MONEY"].ToString());
dtoCard.CardMoneyEx = Int32.Parse(dr["CARD_MONEY_EX"].ToString());
dtoCard.CardBuyDate = DateTime.Parse(dr["CARD_BUY_DATE"].ToString());
dtoCard.RechargeID = Int32.Parse(dr["RECHARGE_ID"].ToString());
dtoCard.CustomerID = dr["CUS_ID"].ToString();
}
}
return(dtoCard);
}
public IHttpActionResult PostSaveCard([FromBody] CardDTO card)
{
if (card.Id == 0)
{
//when the front-end sends no new ID, this creates a new card
var newCard = new Card();
newCard.Id = card.Id;
newCard.Name = card.Name;
newCard.Hp = card.Hp;
newCard.Attack1 = card.Attack1;
newCard.Attack2 = card.Attack2;
newCard.ElementId = card.ElementId;
newCard.IsActive = card.IsActive;
database.Cards.Add(newCard);
}
else
{
//when the front-end sends an ID, this section is updatng an old card
var existingCard = database.Cards.SingleOrDefault(x => x.Id == card.Id);
existingCard.Id = card.Id;
existingCard.Name = card.Name;
existingCard.Hp = card.Hp;
existingCard.Attack1 = card.Attack1;
existingCard.Attack2 = card.Attack2;
existingCard.ElementId = card.ElementId;
existingCard.IsActive = card.IsActive;
}
database.SaveChanges();
return(Ok());
}
public async Task <CardViewModel> Update(int id, CardViewModel card)
{
CardDTO newCard = mapper.Map <CardDTO>(card);
CardDTO updatedCard = await cardService.UpdateAsync(id, newCard);
return(mapper.Map <CardViewModel>(updatedCard));
}
public static Card ToCard(this CardDTO cardDTO)
{
Card newCard = new Card
{
ItemNumber = cardDTO.ItemNumber,
Title = cardDTO.Title,
Description = cardDTO.Description,
Start = cardDTO.Start,
End = cardDTO.End,
Duration = cardDTO?.Duration,
CardsListId = cardDTO.CardsListId,
Complexity = cardDTO?.Complexity
};
if (cardDTO.Discriminator == "PlanCard")
{
PlanCard planCard = (PlanCard)newCard;
planCard.IsDone = ((PlanCardDTO)cardDTO).IsDone;
planCard.DoneUserId = ((PlanCardDTO)cardDTO).DoneUserId;
return(planCard);
}
else
{
HabitCard habitCard = (HabitCard)newCard;
habitCard.DoneCounter = ((HabitCardDTO)cardDTO).DoneCounter;
habitCard.NotDoneCounter = ((HabitCardDTO)cardDTO).NotDoneCounter;
return(habitCard);
}
}
public InHoaDonChuyenTien(ResourceManager rm, CardDTO card = null, string accountNo = null)
{
this.rm = rm;
this.card = card;
this.accountNo = accountNo;
InitializeComponent();
}
public bool Transfer(CardDTO cardInfo, AccountDTO accTo, long balance)
{
try
{
//tru tien
string queryString1 = "UPDATE Account SET Balance-=@bl WHERE AccountID=@accID";
SqlCommand cmd1 = new SqlCommand(queryString1, DataConnection.connect);
cmd1.Parameters.AddWithValue("bl", balance);
cmd1.Parameters.AddWithValue("accID", cardInfo.accountID);
int check1 = cmd1.ExecuteNonQuery();
//cong tien
string queryString2 = "UPDATE Account SET Balance+=@bl WHERE AccountID=@accIDTo";
SqlCommand cmd2 = new SqlCommand(queryString2, DataConnection.connect);
cmd2.Parameters.AddWithValue("bl", balance);
cmd2.Parameters.AddWithValue("accIDTo", accTo.accountID);
int check2 = cmd2.ExecuteNonQuery();
DataConnection.closeConnection();
return(check1 > 0 && check2 > 0);
}
catch (Exception)
{
DataConnection.closeConnection();
return(false);
}
}
public CardDTO CheckCard(string stk)
{
try
{
conn.Open();
string query = "SELECT * FROM tblCard WHERE CardNo=@card";
SqlCommand cmd = new SqlCommand(query, conn);
cmd.Parameters.AddWithValue("card", stk);
SqlDataReader dr = cmd.ExecuteReader();
if (dr.Read())
{
CardDTO card = new CardDTO(
dr["CardNO"].ToString(),
int.Parse(dr["Status"].ToString()),
int.Parse(dr["AccountID"].ToString()),
dr["PIN"].ToString(),
dr["StartDate"].ToString(),
dr["ExpiredDate"].ToString(),
int.Parse(dr["Attempt"].ToString()));
conn.Close();
return(card);
}
return(null);
}
catch (Exception)
{
throw;
}
}
protected PayInCardDirectPostDTO GetPayInCardDirectPost(String userId, string idempotencyKey)
{
WalletDTO wallet = this.GetJohnsWalletWithMoney();
if (userId == null)
{
UserNaturalDTO user = this.GetJohn();
userId = user.Id;
}
CardRegistrationPostDTO cardRegistrationPost = new CardRegistrationPostDTO(userId, CurrencyIso.EUR);
CardRegistrationDTO cardRegistration = this.Api.CardRegistrations.Create(idempotencyKey, cardRegistrationPost);
CardRegistrationPutDTO cardRegistrationPut = new CardRegistrationPutDTO();
cardRegistrationPut.RegistrationData = this.GetPaylineCorrectRegistartionData(cardRegistration);
cardRegistration = this.Api.CardRegistrations.Update(cardRegistrationPut, cardRegistration.Id);
CardDTO card = this.Api.Cards.Get(cardRegistration.CardId);
// create pay-in CARD DIRECT
PayInCardDirectPostDTO payIn = new PayInCardDirectPostDTO(cardRegistration.UserId, cardRegistration.UserId,
new Money {
Amount = 10000, Currency = CurrencyIso.EUR
}, new Money {
Amount = 0, Currency = CurrencyIso.EUR
},
wallet.Id, "http://test.com", card.Id);
// payment type as CARD
payIn.CardType = card.CardType;
return(payIn);
}
public void InsertCards()
{
using (StreamReader npcIdStream = new StreamReader(FileCardDat, CodePagesEncodingProvider.Instance.GetEncoding(1252)))
{
while ((_line = npcIdStream.ReadLine()) != null)
{
string[] currentLine = _line.Split('\t');
if (currentLine.Length > 2 && currentLine[1] == "VNUM")
{
_card = new CardDTO
{
CardId = Convert.ToInt16(currentLine[2])
};
_itemAreaBegin = true;
}
else if (currentLine.Length > 3 && currentLine[1] == "GROUP")
{
if (!_itemAreaBegin)
{
continue;
}
_card.Level = Convert.ToByte(currentLine[3]);
}
else if (currentLine.Length > 3 && currentLine[1] == "EFFECT")
{
_card.EffectId = Convert.ToInt32(currentLine[2]);
}
else if (currentLine.Length > 3 && currentLine[1] == "STYLE")
{
_card.BuffType = (BCardType.CardType)Convert.ToByte(currentLine[3]);
}
else if (currentLine.Length > 3 && currentLine[1] == "TIME")
{
_card.Duration = Convert.ToInt32(currentLine[2]);
_card.Delay = Convert.ToInt32(currentLine[3]);
}
else
{
if (currentLine.Length > 3 && currentLine[1] == "1ST")
{
AddFirstData(currentLine);
}
else if (currentLine.Length > 3 && currentLine[1] == "2ST")
{
AddSecondData(currentLine);
}
else if (currentLine.Length > 3 && currentLine[1] == "LAST")
{
AddThirdData(currentLine);
}
}
}
DAOFactory.CardDAO.InsertOrUpdate(_cards);
DAOFactory.BcardDAO.InsertOrUpdate(Bcards);
Logger.Log.Info(string.Format(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.CARDS_PARSED), _counter));
npcIdStream.Close();
}
}
public IHttpActionResult CreateCard(CardDTO cardDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
Card card = converter.ConvertToCard(cardDTO);
card.Deck = moderation.FindDeckByName(cardDTO.DeckName);
card.CardType = moderation.FindCardTypeByName(cardDTO.CardTypeName);
card.Answers = new List <Answer>();
foreach (var answer in cardDTO.Answers)
{
card.Answers.Add(moderation.CreateAnswer(converter.ConvertToAnswer(answer)));
}
moderation.CreateCard(card);
return(Ok(converterToDTO.ConvertToCardDTO(card)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public GameDTO PlayCard()
{
GameDTO game = new GameDTO(); // get game from parameter
int cardToPlay = 1; // get cardtoplay from parameter
int target = 1; // get target on the field from card to play
if (!CheckForTurn(game))
{
return(game);
}
int currentMana = game.connectedPlayers[0].hero.mana;
int currentDeathEssence = game.connectedPlayers[0].hero.deathessence;
CardDTO playableCard = game.connectedPlayers[0].cardsInHand[cardToPlay];
if (currentMana < playableCard.blue_mana)
{
//send error function "You dont have enough resources to do that!"
return(game);
}
if (currentDeathEssence < playableCard.death_essence)
{
//send error function "You dont have enough resources to do that!"
return(game);
}
ConsumeResources(game, playableCard.blue_mana, playableCard.death_essence);
RemoveCardFromHand(game, cardToPlay);
game.connectedPlayers[0].boardrow.cardSlotList[target].card = playableCard;
return(game);
}
public bool KiemTraGuiHopLe(CardDTO cardsend, decimal money)
{
SqlConnection cnn = Connect();
/*
* SqlCommand cmd = new SqlCommand("spKiemTraHopLeMasterCard", cnn);
* cmd.CommandType = CommandType.StoredProcedure;
* string de_code = code; //Security.Decrypt(code);
*
* cmd.Parameters.Add("@code", SqlDbType.VarChar);
* cmd.Parameters["@code"].Value = de_code;
*/
//string de_code = Security.Decrypt(code);
string strSQL = "Select * From " + cardsend.Type.Trim() + "Balance";
strSQL += " Where Code = 0x" + cardsend.Code;
strSQL += " and Balance >= " + money;
SqlCommand cmd = new SqlCommand(strSQL, cnn);
SqlDataReader dr = cmd.ExecuteReader();
if (dr.Read())
{
Disconnect();
return(true);
}
Disconnect();
return(false);
}
public async Task CreateCard_RightObjectPassed_ReturnsCreatedAtAction()
{
// Arrange
var controller = new CardsController(flashcardDbContextMock.Object, logger);
var rightCard = new CardDTO
{
Type = "Teszt tipus",
Card_number = 3,
Question_text = "Teszt kartya kerdes",
Question_picture = "kep.jpg",
Answer_text = "Teszt kartya valasz",
Answer_picture = "kep2.jpg",
Deck = new DeckInfoDTO
{
Id = 1,
Name = "Teszt csomag",
Module = Module.A,
Deck_number = 1,
Status = DeckStatus.Approved
}
};
// Act
var result = await controller.CreateCard(rightCard);
// Asssert
Assert.IsType <CreatedAtActionResult>(result.Result);
}
public CardDTO Insert(ref CardDTO card)
{
try
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
Card entity = new Card();
Mapper.Mappers.CardMapper.ToCard(card, entity);
CardDTO dto = new CardDTO();
if (context.Card.FirstOrDefault(s => s.CardId == entity.CardId) != null)
{
return(null);
}
context.Card.Add(entity);
context.SaveChanges();
if (Mapper.Mappers.CardMapper.ToCardDTO(entity, card))
{
return(card);
}
return(null);
}
}
catch (Exception e)
{
Logger.Error(e);
return(null);
}
}
public SaveResult InsertOrUpdate(CardDTO card)
{
try
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
long CardId = card.CardId;
Card entity = context.Card.FirstOrDefault(c => c.CardId == CardId);
if (entity == null)
{
card = insert(card, context);
return(SaveResult.Inserted);
}
card = update(entity, card, context);
return(SaveResult.Updated);
}
}
catch (Exception e)
{
Logger.Error(string.Format(Language.Instance.GetMessageFromKey("UPDATE_CARD_ERROR"), card.CardId, e.Message), e);
return(SaveResult.Error);
}
}
public void Insert(List <CardDTO> cards)
{
try
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
context.Configuration.AutoDetectChangesEnabled = false;
foreach (CardDTO card in cards)
{
CardDTO dto = new CardDTO();
if (context.Card.FirstOrDefault(s => s.CardId == card.CardId) != null)
{
continue;
}
Card entity = new Card();
Mapper.Mappers.CardMapper.ToCard(card, entity);
context.Card.Add(entity);
}
context.Configuration.AutoDetectChangesEnabled = true;
context.SaveChanges();
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
public CardDTO getCardInfo(string cardNo)
{
try
{
string queryString = "SELECT * FROM Card WHERE CardNo=@card";
SqlCommand cmd = new SqlCommand(queryString, DataConnection.connect);
cmd.Parameters.AddWithValue("card", cardNo);
SqlDataReader data = cmd.ExecuteReader();
CardDTO cardDTO = null;
if (data.Read())
{
cardDTO = new CardDTO(data["CardNo"].ToString(),
data["Status"].ToString(),
data["PIN"].ToString(),
DateTime.Parse(data["StartDate"].ToString()),
DateTime.Parse(data["ExpiredDate"].ToString()),
int.Parse(data["Attempt"].ToString()),
int.Parse(data["AccountID"].ToString()));
}
DataConnection.closeConnection();
return(cardDTO);
}
catch (Exception)
{
DataConnection.closeConnection();
return(null);
}
}
public int AddNewCard(int cardListId, string cardName)
{
if (!string.IsNullOrWhiteSpace(cardName) && cardName.Length > 0 && cardName.Length <= 255)
{
var card = new CardDTO
{
Name = cardName,
Description = "",
Comments = new List <CommentDTO>()
};
var cardList = Get(cardListId);
if (cardList == null)
{
return(0);
}
cardList.Cards.Add(card);
Save(cardList);
return(card.Id);
}
else
{
return(0);
}
}
public IActionResult RollCard(int id, CardDTO card)
{
var cardFormGame = games[id].GetCard(card.x, card.y);
//game.GetCard(card.x, card.y);
return(Ok());
}
private void btnNumberEnter_Click(object sender, EventArgs e)
{
this.accountNo = txtPIN.Text;
CardDTO card = cardBUL.CheckCard(this.accountNo);
if (card != null)
{
if (card.Attemp > 3)
{
MessageBox.Show("Tài khoản của bạn đã bị khóa");
this.Hide();
(new Validate()).Show();
}
else
{
(new EnterPin(this.accountNo)).Show();
this.Hide();
}
}
else
{
this.Hide();
Validate validateForm = new Validate();
validateForm.Show();
validateForm.pbThe.Image = theRa;
}
}
