Exemple #1
0
        public async Task <ActionResult> ClaimPrizeModal(ClaimPrizeModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var userId = User.Identity.GetUserId <int>();
            var prize  = await PrizeReader.GetUserPrize(userId, model.Id);

            if (prize.Status != PrizeStatus.Unclaimed)
            {
                return(CloseModalSuccess());
            }

            if (model.IsPointsClaim)
            {
                var paymentMethod = await PaymentReader.GetMethod(prize.Data);

                if (paymentMethod == null)
                {
                    return(CloseModalError("Unknown Error"));
                }

                var paymentUserMethod = await PaymentReader.GetUserMethod(userId, paymentMethod.Id);

                if (paymentUserMethod == null)
                {
                    await PaymentWriter.CreateMethod(userId, paymentMethod.Id);
                }

                paymentUserMethod = await PaymentReader.GetUserMethod(userId, paymentMethod.Id);

                if (paymentUserMethod == null)
                {
                    return(CloseModalError("Unknown Error"));
                }

                model.Data3 = paymentUserMethod.Data;
            }

            if (string.IsNullOrEmpty(model.Data3))
            {
                ModelState.AddModelError("", "Invalid Crypto Address");
                return(View(model));
            }

            var result = await PrizeWriter.ClaimPrize(userId, model);

            if (!ModelState.IsWriterResultValid(result))
            {
                return(View(model));
            }

            return(CloseModalSuccess());
        }
Exemple #2
0
        public async Task <ActionResult> CreatePrizePoolModal(CreatePrizePoolModel model)
        {
            if (!ModelState.IsValid)
            {
                model.Games = await GetPendingGames();

                return(View(model));
            }


            if (model.Type == Enums.PrizeType.Points)
            {
                model.Data  = null;
                model.Data2 = null;
            }
            else if (model.Type == Enums.PrizeType.Crypto)
            {
                var isValid = true;
                if (string.IsNullOrEmpty(model.Data))
                {
                    // coin symbol missing
                    ModelState.AddModelError("", "Coin symbol missing");
                    isValid = false;
                }

                if (!decimal.TryParse(model.Data2, out var parsedAmount) || parsedAmount < 0.00000001m)
                {
                    // invalid amount
                    ModelState.AddModelError("", "Invalid amount");
                    isValid = false;
                }

                if (!isValid)
                {
                    model.Games = await GetPendingGames();

                    return(View(model));
                }
            }

            var result = await PrizeWriter.CreatePrizePool(model);

            if (!ModelState.IsWriterResultValid(result))
            {
                model.Games = await GetPendingGames();

                return(View(model));
            }
            return(CloseModalSuccess());
        }
Exemple #3
0
        public async Task <ActionResult> UpdatePrizePaymentModal(UpdatePrizePaymenModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var result = await PrizeWriter.UpdatePrizePayment(model);

            if (!ModelState.IsWriterResultValid(result))
            {
                return(View(model));
            }

            return(CloseModalSuccess());
        }