public async Task <ResponseModel> InsertUpdate(CardInputViewModel cardInputViewModel)
{
try
{
var validateCard = ValidateCard(cardInputViewModel.cardNumber, cardInputViewModel.expiryDate);
if (validateCard.result == "Valid")
{
CardNumber cardNumber = new CardNumber();
var cardType = validateCard.CardType;
CardTypeEnum cardTypeEnum = cardType.ToEnum <CardTypeEnum>();
var cardNum = await cardNumberRepo.Table.Where(x => x.CNumber == cardInputViewModel.cardNumber).SingleOrDefaultAsync();
if (cardNum == null)
{
cardNumber.Id = 0;
cardNumber.CNumber = cardInputViewModel.cardNumber;
cardNumber.CardTypeId = (long)cardTypeEnum;
cardNumber.Expiry = cardInputViewModel.expiryDate;
cardNumber.Active = true;
cardNumber.Created = DateTime.Now;
cardNumber.Modified = DateTime.Now;
cardNumber.Author = 1;
cardNumber.Editor = 1;
}
else
{
cardNumber.Id = cardNum.Id;
cardNumber.CNumber = cardInputViewModel.cardNumber;
cardNumber.CardTypeId = (long)cardTypeEnum;
cardNumber.Expiry = cardInputViewModel.expiryDate;
cardNumber.Active = true;
cardNumber.Created = cardNum.Created;
cardNumber.Modified = DateTime.Now;
cardNumber.Author = cardNum.Author;
cardNumber.Editor = 1;
}
var result = cardRepo.InsertUpdate(cardNumber);
return(HelperClass.Response(true
, GlobalDecleration._savedSuccesfully
, result
));
}
else
{
return(HelperClass.Response(false
, GlobalDecleration._internalServerError
, "Invalid Card"
));
}
}
catch (Exception ex)
{
ExceptionHandle.PrintException(ex);
return(HelperClass.Response(false,
GlobalDecleration._internalServerError,
null
));
}
}
IEnumerator executeCard(CardTypeEnum cardType)
{
//yield return new WaitForSeconds(SecondsPerCard);
Debug.Log("preforming a " + cardType.ToString());
switch (cardType)
{
case CardTypeEnum.Forward:
var newPosition = goTowards(facingDirection);
yield return(StartCoroutine(LerpTo((Vector3)newPosition, turtle.transform.localRotation, turtle.transform.localScale, turtle.transform)));
break;
case CardTypeEnum.TurnLeft:
updateDirection(ref facingDirection, towardsRight: false);
yield return(StartCoroutine(rotate(turtle.transform, 90))); // lerp turtle.rectTransform.Rotate(0, 0, 90);
break;
case CardTypeEnum.TurnRight:
updateDirection(ref facingDirection, towardsRight: true);
yield return(StartCoroutine(rotate(turtle.transform, -90))); // lerp turtle.rectTransform.Rotate(0, 0, -90);
break;
case CardTypeEnum.Function:
yield return(StartCoroutine(executeFunction()));
break;
case CardTypeEnum.Error:
default:
break;
}
}
public Card(Texture2D front, Texture2D back, CardTypeEnum type, CardColorEnum color = CardColorEnum.None, CardSymbolEnum symbol = CardSymbolEnum.None)
: this(front, back)
{
Type = type;
Color = color;
Symbol = symbol;
}
protected bool consumeCheck()
{
int consumeEnergy = this.cardData.consumeEnergy;
if (consumeEnergy <= 0)
{
return(true);
}
CardTypeEnum cardType = this.cardData.cardType;
PlayerData battlePlayerData = AppContext.instance.battleManager.battlePlayerData;
switch (cardType)
{
case CardTypeEnum.ACTION:
return(battlePlayerData.actionValue >= consumeEnergy);
case CardTypeEnum.MAGIC:
return(battlePlayerData.magicValue >= consumeEnergy);
case CardTypeEnum.BLEED:
return(battlePlayerData.hpValue >= consumeEnergy);
default:
Debug.LogError("incorrect card type : " + consumeEnergy);
return(false);
}
}
/// <summary>
/// 功能：根据CardTypeEnum枚举值返回相应的卡类型编码
/// </summary>
/// <param name="CardType">CardTypeEnum枚举</param>
/// <returns></returns>
private Int32 ReturnCardType(CardTypeEnum CardType)
{
switch (CardType)
{
case CardTypeEnum.blankCard:
return(1); //"空白卡"
case CardTypeEnum.openAccountCard:
return(2); //"开户卡"
case CardTypeEnum.userCard:
return(3); // "用户卡"
case CardTypeEnum.reMakeCard:
return(4); // "补卡后的卡"
case CardTypeEnum.clearCard:
return(5); // "退卡后的卡";
case CardTypeEnum.checkCard:
return(6); // "检查卡";
case CardTypeEnum.unKnowCard:
return(7); //"未知卡";
default:
return(7); //"未知卡";
}
}
public void ToEnum_Passing_Valid_String_Name_Enumeracion_Returns_Enumeracion()
{
var name = "American Express";
var expected = CardTypeEnum.Amex;
var actual = CardTypeEnum.ToEnum(name);
Assert.AreEqual(expected, actual);
}
public void ToEnum_Passing_Valid_String_ShortName_Enumeracion_Returns_Enumeracion()
{
var name = "Visa";
var expected = CardTypeEnum.Visa;
var actual = CardTypeEnum.ToEnum(name);
Assert.AreEqual(expected, actual);
}
public void ToEnum_Passing_Invalid_String_Name_Enumeracion_Returns_Null()
{
var name = Guid.NewGuid().ToString();
CardTypeEnum?expected = null;
var actual = CardTypeEnum.ToEnum(name);
Assert.AreEqual(expected, actual);
}
public async Task <ResponseModel> SaveCardNumber(CardInputViewModel cardInputViewModel)
{
try
{
var validateCard = ValidateCard(cardInputViewModel.cardNumber, cardInputViewModel.expiryDate);
if (validateCard.result == "Valid")
{
var cardType = validateCard.CardType;
var cardNum = await cardNumberRepo.Table.Where(x => x.CNumber == cardInputViewModel.cardNumber).SingleOrDefaultAsync();
if (cardNum == null)
{
CardTypeEnum cardTypeEnum = validateCard.CardType.ToEnum <CardTypeEnum>();
CardNumber cardNumber = new CardNumber
{
Id = 0,
CNumber = cardInputViewModel.cardNumber,
CardTypeId = (long)cardTypeEnum,
Active = true,
Created = DateTime.Now,
Modified = DateTime.Now,
Author = 1,
Editor = 1
};
await cardNumberRepo.Insert(cardNumber);
}
else
{
CardTypeEnum cardTypeEnum = cardInputViewModel.cardNumber.ToEnum <CardTypeEnum>();
CardNumber cardNumber = new CardNumber
{
Id = cardNum.Id,
CNumber = cardInputViewModel.cardNumber,
CardTypeId = (long)cardTypeEnum,
Active = true,
Created = cardNum.Created,
Modified = DateTime.Now,
Author = cardNum.Author,
Editor = 1
};
await cardNumberRepo.Update(cardNumber);
}
}
return(HelperClass.Response(true
, GlobalDecleration._successAction
, null
));
}
catch (Exception ex)
{
ExceptionHandle.PrintException(ex);
return(HelperClass.Response(false,
GlobalDecleration._internalServerError,
null
));
}
}
public void ToEnum_Passing_Valid_IntName_Enumeracion_Returns_Enumeracion()
{
var value = 3;
var expected = CardTypeEnum.MasterCard;
var actual = CardTypeEnum.ToEnum(value);
Assert.AreEqual(expected, actual);
}
public void ToEnum_Passing_Invalid_Int_Name_Enumeracion_Returns_Null()
{
var value = new Random().Next();
CardTypeEnum?expected = null;
var actual = CardTypeEnum.ToEnum(value);
Assert.AreEqual(expected, actual);
}
public void GetAll_Passing_Nothing_Returns_Enumeracion_List()
{
var expected = 3;
var actual = CardTypeEnum.GetAll();
Assert.AreEqual(expected, actual.Count());
CollectionAssert.Contains(actual, CardTypeEnum.Amex);
CollectionAssert.Contains(actual, CardTypeEnum.MasterCard);
CollectionAssert.Contains(actual, CardTypeEnum.Visa);
}
public Card(CardTypeEnum type, int no)
{
if (no > 13 || no < 1)
{
throw new ArgumentException("Card No cannot be less than 1 or more than 13");
}
this.Type = type;
this.No = no;
this.KeyList = new Dictionary <string, object>();
ParentDeck = null;
}
private IPaymentGatewayService GetGatewayService(Card card)
{
IPaymentGatewayService PaymentGatewayService = null;
string cardbranc = card.CardBrand;
CardTypeEnum cardType = (CardTypeEnum)card.CardType;
if (cardType == CardTypeEnum.Credit)
{
PaymentGatewayService = BankFactory.GetPaymentGateway(BankFactory.BANCO_X);
}
return(PaymentGatewayService);
}
/// 创建卡牌
public Card CreateCard(string name, int value, Type dataType, int id, CardTypeEnum typeEnum)
{
Card card = new Card(name, value);
card.SetDataFrom(dataType, id);
card.SetCardType(typeEnum);
CardControl cc = new CardControl();
cc.Init(card);
cardUUId2Control.Add(card.UUID, cc);
return(card);
}
private string GetCardType(CardTypeEnum cardType)
{
switch (cardType)
{
case CardTypeEnum.Diamond: return("Diamond");
case CardTypeEnum.Heart: return("Heart");
case CardTypeEnum.Flower: return("Flower");
default: return("Spade");
}
}
public static string GetCardTypeName(this CardTypeEnum cardType)
{
switch (cardType)
{
case CardTypeEnum.Diamond: return("Diamond");
case CardTypeEnum.Heart: return("Heart");
case CardTypeEnum.Flower: return("Flower");
case CardTypeEnum.Spade: return("Spade");
default: return(string.Empty);
}
}
public Card(CardTypeEnum cardType, CardSuitsEnum cardSuit)// יוצרת קלף חדש ע"פ צורה ומספר
{
InitializeComponent();
this.cardSuit = cardSuit;
this.cardType = cardType;
cardId = ((int)cardSuit * 13) + (int)cardType + 1;
AssignCardImage();
BackgroundImageLayout = ImageLayout.Center;
cardImage = BackgroundImage;
Width = cardImage.Width + 5;
Height = cardImage.Height + 5;
Click += Card_Click;
}
public Card(int cardId) //יוצרת קלף חדש ע"פ מזהה
{
InitializeComponent();
this.cardId = cardId;
this.cardSuit = (CardSuitsEnum)((cardId - (int)cardType - 1) / 13);
this.cardType = (CardTypeEnum)((int)cardId - 1 - (int)cardSuit * 13);
cardId = ((int)cardSuit * 13) + (int)cardType + 1;
AssignCardImage();
BackgroundImageLayout = ImageLayout.Center;
if (cardId <= 52)
{
cardImage = BackgroundImage;
Width = cardImage.Width + 5;
Height = cardImage.Height + 5;
}
Click += Card_Click;
}
public Card(int id)
{
status = StatusEnum.Invisible;
ID = id;
if (id < 0 || id >= 54)
{
throw new ArgumentException("id must be between 0 and 53");
}
else
{
if (id == 52)
{
CardType = CardTypeEnum.Joker;
Value = 0x3f3f3f3f;
Suit = SuitEnum.Spade;
}
else if (id == 53)
{
CardType = CardTypeEnum.Joker;
Value = 0x3f3f3f40;
Suit = SuitEnum.Diamond;
}
else
{
int suit = id / 13;
Suit = (SuitEnum)suit;
Value = (id % 13) + 1;
if (Value == 1)
{
CardType = CardTypeEnum.Ace;
}
else if (2 <= Value && Value <= 10)
{
CardType = CardTypeEnum.Number;
}
else
{
CardType = CardTypeEnum.Face;
}
}
}
}
private void showCardConsume()
{
// 显示卡牌耗费背景
this.cardConsumeBg.gameObject.SetActive(true);
CardTypeEnum cardType = this.cardData.cardType;
switch (cardType)
{
case CardTypeEnum.ACTION:
string actionUrl = CustomUrlString.consumePreTexture + cardType;
this.cardConsumeBg.sprite = AppContext.instance.assetsManager.getAssetByUrlSync <Sprite> (actionUrl);
break;
case CardTypeEnum.SPELL:
string spellUrl = CustomUrlString.consumePreTexture + cardType;
this.cardConsumeBg.sprite = AppContext.instance.assetsManager.getAssetByUrlSync <Sprite> (spellUrl);
break;
case CardTypeEnum.BLEED:
string bleedUrl = CustomUrlString.consumePreTexture + cardType;
this.cardConsumeBg.sprite = AppContext.instance.assetsManager.getAssetByUrlSync <Sprite> (bleedUrl);
break;
case CardTypeEnum.EQUIPMENT:
case CardTypeEnum.ATTACK:
case CardTypeEnum.MAGIC:
case CardTypeEnum.PRAY:
case CardTypeEnum.REFLEX:
case CardTypeEnum.SPECIAL:
this.cardConsumeBg.gameObject.SetActive(false);
break;
default:
Debug.LogWarning("card type exceed value: " + cardType);
break;
}
// 显示卡牌消耗数值
this.cardConsume.text = this.cardData.consumeEnergy.ToString();
}
/// <summary>
/// Перевод типа карты
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public string GetCardTypeTranslation(CardTypeEnum type)
{
string result = "";
switch (type)
{
case (CardTypeEnum.MC):
result = "Магнитная карта";
break;
case (CardTypeEnum.EC):
result = "Таблетка";
break;
case (CardTypeEnum.RC):
result = "Радиокарта";
break;
case (CardTypeEnum.SC):
result = "Смарт-карта";
break;
case (CardTypeEnum.CC):
result = "Штрихкодовая";
break;
case (CardTypeEnum.PP):
result = "Карта PetrolPlus";
break;
case (CardTypeEnum.BI):
result = "Ведомость";
break;
case (CardTypeEnum.CI):
result = "Талон";
break;
}
return(result);
}
public void ParseFromBytes(byte[] buffer, int offset)
{
_cardType = (CardTypeEnum)(buffer[offset] & (byte)CardTypeEnum.CardMask);
}
public Card(CardTypeEnum aCardType)
{
this.CardType = aCardType;
ReadLanguageConfiguration();
}
public GameCard(CardTypeEnum type)
{
cardType = type;
switch (cardType)
{
case CardTypeEnum.BLUEDOOR:
this.cardTypeClass = CardTypeClassEnum.DOOR;
break;
case CardTypeEnum.BLUEKEY:
this.cardTypeClass = CardTypeClassEnum.KEY;
textureOffset = cardWidth;
break;
case CardTypeEnum.BLUESUN:
this.cardTypeClass = CardTypeClassEnum.SUN;
textureOffset = cardWidth * 2;
break;
case CardTypeEnum.BLUEMOON:
this.cardTypeClass = CardTypeClassEnum.MOON;
textureOffset = cardWidth * 3;
break;
case CardTypeEnum.GREENDOOR:
this.cardTypeClass = CardTypeClassEnum.DOOR;
textureOffset = cardWidth * 4;
break;
case CardTypeEnum.GREENKEY:
this.cardTypeClass = CardTypeClassEnum.KEY;
textureOffset = cardWidth * 5;
break;
case CardTypeEnum.GREENSUN:
this.cardTypeClass = CardTypeClassEnum.SUN;
textureOffset = cardWidth * 6;
break;
case CardTypeEnum.GREENMOON:
this.cardTypeClass = CardTypeClassEnum.MOON;
textureOffset = cardWidth * 7;
break;
case CardTypeEnum.REDDOOR:
this.cardTypeClass = CardTypeClassEnum.DOOR;
textureOffset = cardWidth * 8;
break;
case CardTypeEnum.REDKEY:
this.cardTypeClass = CardTypeClassEnum.KEY;
textureOffset = cardWidth * 9;
break;
case CardTypeEnum.REDSUN:
this.cardTypeClass = CardTypeClassEnum.SUN;
textureOffset = cardWidth * 10;
break;
case CardTypeEnum.REDMOON:
this.cardTypeClass = CardTypeClassEnum.MOON;
textureOffset = cardWidth * 11;
break;
case CardTypeEnum.ORANGEDOOR:
this.cardTypeClass = CardTypeClassEnum.DOOR;
textureOffset = cardWidth * 12;
break;
case CardTypeEnum.ORANGEKEY:
this.cardTypeClass = CardTypeClassEnum.KEY;
textureOffset = cardWidth * 13;
break;
case CardTypeEnum.ORANGESUN:
this.cardTypeClass = CardTypeClassEnum.SUN;
textureOffset = cardWidth * 14;
break;
case CardTypeEnum.ORANGEMOON:
this.cardTypeClass = CardTypeClassEnum.MOON;
textureOffset = cardWidth * 15;
break;
case CardTypeEnum.NIGHTMARE:
textureOffset = cardWidth * 16;
break;
}
textureRect = new Rectangle(textureOffset,0,cardWidth,cardHeight);
}
public void SetCardType(CardTypeEnum typeEnum)
{
CardTypeEnum = typeEnum;
}
public CardProperties(CardTypeEnum type, int count)
{
this.type = type;
this.count = count;
}
public Card(CardTypeEnum type, NaipeTypeEnum naipe, bool changeValue = false)
{
Type = type;
Naipe = naipe;
ChangeValue = changeValue;
}
public void ParseFromBytes(byte[] buffer, int offset)
{
_cardType = (CardTypeEnum)(buffer[offset] & (byte)CardTypeEnum.CardMask);
}
public Card(CardTypeEnum cardType, int cardNumber)
{
this.CardType = cardType;
this.CardNumber = cardNumber;
}
private async Task AskLayoutType(IDialogContext context, IAwaitable <CardTypeEnum> result)
{
_cardType = await result;
PromptDialog.Choice(context, AfterMessageReceivedAsync,
(IEnumerable <LayoutTypeEnum>)Enum.GetValues(typeof(LayoutTypeEnum)), "請選擇排版類型？");
}