Example #1
0
        public async void Delete()
        {
            var mock  = new ServiceMockFacade <ICreditCardRepository>();
            var model = new ApiCreditCardRequestModel();

            mock.RepositoryMock.Setup(x => x.Delete(It.IsAny <int>())).Returns(Task.CompletedTask);
            var service = new CreditCardService(mock.LoggerMock.Object,
                                                mock.RepositoryMock.Object,
                                                mock.ModelValidatorMockFactory.CreditCardModelValidatorMock.Object,
                                                mock.BOLMapperMockFactory.BOLCreditCardMapperMock,
                                                mock.DALMapperMockFactory.DALCreditCardMapperMock,
                                                mock.BOLMapperMockFactory.BOLPersonCreditCardMapperMock,
                                                mock.DALMapperMockFactory.DALPersonCreditCardMapperMock,
                                                mock.BOLMapperMockFactory.BOLSalesOrderHeaderMapperMock,
                                                mock.DALMapperMockFactory.DALSalesOrderHeaderMapperMock);

            ActionResponse response = await service.Delete(default(int));

            response.Should().NotBeNull();
            mock.RepositoryMock.Verify(x => x.Delete(It.IsAny <int>()));
            mock.ModelValidatorMockFactory.CreditCardModelValidatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <int>()));
        }
Example #2
0
        public async void PersonCreditCards_Exists()
        {
            var mock    = new ServiceMockFacade <ICreditCardRepository>();
            var records = new List <PersonCreditCard>();

            records.Add(new PersonCreditCard());
            mock.RepositoryMock.Setup(x => x.PersonCreditCards(default(int), It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(records));
            var service = new CreditCardService(mock.LoggerMock.Object,
                                                mock.RepositoryMock.Object,
                                                mock.ModelValidatorMockFactory.CreditCardModelValidatorMock.Object,
                                                mock.BOLMapperMockFactory.BOLCreditCardMapperMock,
                                                mock.DALMapperMockFactory.DALCreditCardMapperMock,
                                                mock.BOLMapperMockFactory.BOLPersonCreditCardMapperMock,
                                                mock.DALMapperMockFactory.DALPersonCreditCardMapperMock,
                                                mock.BOLMapperMockFactory.BOLSalesOrderHeaderMapperMock,
                                                mock.DALMapperMockFactory.DALSalesOrderHeaderMapperMock);

            List <ApiPersonCreditCardResponseModel> response = await service.PersonCreditCards(default(int));

            response.Should().NotBeEmpty();
            mock.RepositoryMock.Verify(x => x.PersonCreditCards(default(int), It.IsAny <int>(), It.IsAny <int>()));
        }
Example #3
0
        public async void Update()
        {
            var mock  = new ServiceMockFacade <ICreditCardRepository>();
            var model = new ApiCreditCardRequestModel();

            mock.RepositoryMock.Setup(x => x.Create(It.IsAny <CreditCard>())).Returns(Task.FromResult(new CreditCard()));
            mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(new CreditCard()));
            var service = new CreditCardService(mock.LoggerMock.Object,
                                                mock.RepositoryMock.Object,
                                                mock.ModelValidatorMockFactory.CreditCardModelValidatorMock.Object,
                                                mock.BOLMapperMockFactory.BOLCreditCardMapperMock,
                                                mock.DALMapperMockFactory.DALCreditCardMapperMock,
                                                mock.BOLMapperMockFactory.BOLPersonCreditCardMapperMock,
                                                mock.DALMapperMockFactory.DALPersonCreditCardMapperMock,
                                                mock.BOLMapperMockFactory.BOLSalesOrderHeaderMapperMock,
                                                mock.DALMapperMockFactory.DALSalesOrderHeaderMapperMock);

            UpdateResponse <ApiCreditCardResponseModel> response = await service.Update(default(int), model);

            response.Should().NotBeNull();
            mock.ModelValidatorMockFactory.CreditCardModelValidatorMock.Verify(x => x.ValidateUpdateAsync(It.IsAny <int>(), It.IsAny <ApiCreditCardRequestModel>()));
            mock.RepositoryMock.Verify(x => x.Update(It.IsAny <CreditCard>()));
        }
 public CreditCardController()
 {
     _unitOfWork = new CreditCardService();
 }
Example #5
0
 public CreditCardsController(CreditCardService creditCardService)
 {
     _creditCardService = creditCardService;
 }
Example #6
0
 public CreditCardController(CreditCardService service) => _service = service;
Example #7
0
 public OrdersController(AuthService authService, CreditCardService creditCardService, TransactionLogService transactionLogService)
 {
     this.authService           = authService;
     this.creditCardService     = creditCardService;
     this.transactionLogService = transactionLogService;
 }
 public CreditCardController(CreditCardService service)
 {
     this.service = service;
 }
Example #9
0
 public CreditCardListViewModel(CreditCardService creditCardService)
 {
     _creditCardService = creditCardService;
     CreditCardList     = GetCreditCards();
 }
Example #10
0
        public bool CompleteTransaction(Job job, ActivityLogAddRequest add)
        {
            bool success = false;

            List <ActivityLog> list = _ActivityLogService.GetByJobId(add.JobId);

            foreach (var activity in list)
            {
                int currentStatus = activity.TargetValue;

                if (currentStatus == (int)JobStatus.BringgOnTheWay)
                {
                    _timeCreated = activity.IdCreated;
                }
                if (currentStatus == (int)JobStatus.BringgDone)
                {
                    _timeCompleted = activity.IdCreated;
                }
            }
            TimeSpan timeDifference = _timeCompleted.Subtract(_timeCreated);
            double   toMinutes      = timeDifference.TotalMinutes;

            CreditCardService cardService      = new CreditCardService();
            PaymentRequest    payment          = new PaymentRequest();
            BrainTreeService  brainTreeService = new BrainTreeService();

            List <string> Slugs = new List <string>();

            Slugs.Add("base-price");
            Slugs.Add("price-per-minute");
            Slugs.Add("minimum-job-duration");
            Slugs.Add("website-pricing-model");

            Dictionary <string, WebsiteSettings> dict = WebsiteSettingsServices.getWebsiteSettingsDictionaryBySlug(job.WebsiteId, Slugs);

            WebsiteSettings pricingModel = (dict["website-pricing-model"]);
            WebsiteSettings basePrice    = (dict["base-price"]);
            WebsiteSettings pricePerMin  = (dict["price-per-minute"]);
            WebsiteSettings jobDuration  = (dict["minimum-job-duration"]);

            // - Switch statement to calculate service cost depending on the website's pricing model

            int pricingModelValue = Convert.ToInt32(pricingModel.SettingsValue);

            switch (pricingModelValue)
            {
            case 1:
                _basePrice  = Convert.ToDouble(basePrice.SettingsValue);
                _totalPrice = _basePrice;
                break;

            case 2:
                _webPrice       = Convert.ToDouble(pricePerMin.SettingsValue);
                _minJobDuration = Convert.ToDouble(jobDuration.SettingsValue);

                if (toMinutes <= _minJobDuration)
                {
                    _totalPrice = _webPrice * _minJobDuration;
                }
                else
                {
                    _totalPrice = _webPrice * toMinutes;
                }

                break;

            case 3:
                _webPrice   = Convert.ToDouble(pricePerMin.SettingsValue);
                _basePrice  = Convert.ToDouble(basePrice.SettingsValue);
                _totalPrice = _webPrice + _basePrice;
                break;
            }


            JobsService.UpdateJobPrice(add.JobId, _totalPrice);

            if (job.UserId != null)
            {
                payment.UserId = job.UserId;
            }
            else
            {
                payment.UserId = job.Phone;
            }


            payment.ExternalCardIdNonce = job.PaymentNonce;
            payment.ItemCost            = (decimal)_totalPrice;


            brainTreeService.AdminPaymentService(payment, job.Id);

            //This is where my contribution begins:


            //once the payment goes through, insert the referral code for user A. Existance of a TokenHash will determine if we need to award an userA.
            //NOTE: User A is the initial friend who referred User B.

            String TokenHash = _UserProfileService.GetTokenHashByUserId(job.UserId);
            //string TokenHash = "CED28811-C2DF-4629-8D2B-AE3C478A5A82"; --FOR TESTING PURPOSES
            Guid TokenGuid;

            Guid.TryParse(TokenHash, out TokenGuid);


            if (TokenHash != null)
            {
                bool TokenUsed = TokenService.isTokenUsedReferral(TokenHash);

                Token GetUserA = TokenService.userGetByGuid(TokenGuid);

                string    UserAId        = GetUserA.UserId;
                int       CouponReferral = GetUserA.TokenType;
                TokenType referral       = (TokenType)CouponReferral; //parsing the int into an enum

                if (UserAId != null && referral == TokenType.Invite && TokenUsed == false)
                {
                    //give User A a credit of 25 dollars
                    CouponsDomain userCoupon = TokenService.GetReferralTokenByGuid(TokenHash);

                    UserCreditsRequest insertUserACredits = new UserCreditsRequest();
                    insertUserACredits.Amount          = userCoupon.CouponValue;
                    insertUserACredits.TransactionType = "Add";
                    insertUserACredits.UserId          = UserAId;

                    int forTargetValue = _CreditsService.InsertUserCredits(insertUserACredits);


                    //then update the activity log for USER A to tell them that their friend completed their first order and that they were rewarded credits
                    ActivityLogAddRequest addCreditFriend = new ActivityLogAddRequest();

                    addCreditFriend.ActivityType = ActivityTypeId.CreditsFriend;
                    addCreditFriend.JobId        = job.Id;
                    addCreditFriend.TargetValue  = forTargetValue;
                    addCreditFriend.RawResponse  = Newtonsoft.Json.JsonConvert.SerializeObject(insertUserACredits);
                    _ActivityLogService.Insert(UserAId, addCreditFriend);

                    //update user B's activity log to show that they used the credits for their first payment
                    ActivityLogAddRequest addCredit = new ActivityLogAddRequest();

                    addCredit.ActivityType = ActivityTypeId.Credits;
                    addCredit.JobId        = job.Id;
                    addCredit.TargetValue  = forTargetValue;
                    addCredit.RawResponse  = Newtonsoft.Json.JsonConvert.SerializeObject(insertUserACredits);
                    _ActivityLogService.Insert(UserAId, addCredit);
                }
            }

            bool successpay = AdminPaymentService(payment, job.Id);

            if (successpay)
            {
                JobsService.UpdateJobStatus(JobStatus.Complete, job.ExternalJobId);

                ActivityLogAddRequest log = new ActivityLogAddRequest();
                log.JobId        = job.Id;
                log.TargetValue  = (int)JobStatus.Complete;
                log.ActivityType = ActivityTypeId.BringgTaskStatusUpdated;

                _ActivityLogService.Insert((job.UserId == null) ? job.Phone : job.UserId, log);
            }
            else
            {
                success = false;
            }

            return(success);
        }
Example #11
0
        public static CreditCardCurrentTransaction CurrentTransactions(Params request)
        {
            CreditCardCurrentTransaction transaction = new CreditCardCurrentTransaction();

            try
            {
                if (request != null)
                {
                    if (request.Parameter.ContainsKey("cardNo"))
                    {
                        string cardNo = request.Parameter["cardNo"];
                        CreditCardInformation information = CreditCardService.RetrieveCreditCardDetail(cardNo, CreditCardService.RetrieveCreditCardType(cardNo));
                        transaction.CustomerNo = information.CustomerNo;
                        transaction.CreditCards.Add(information);
                        CreditCardCurrentTransaction currentTrx = RetrieveCreditCardCurrentTransactions(cardNo);
                        foreach (CreditCardTransaction trx in currentTrx.Transactions)
                        {
                            transaction.Transactions.Add(trx);
                        }
                    }
                    else if (request.Parameter.ContainsKey("custNo"))
                    {
                        // If a customer has multiple Credit Cards, the "Credit Card Customer No" is still the same for all the credit cards.
                        Params param = new Params()
                        {
                            Parameter = new Dictionary <string, string>()
                        };
                        param.RequestTransType = "GetAllRelatedCreditCardInOneCustNo";
                        param.Parameter.Add("custNo", request.Parameter["custNo"]);
                        param.WSDL = "AllRelatedDetail";
                        ESBData data = EAI.RetrieveESBData(param);
                        transaction.CustomerNo = request.Parameter["custNo"];

                        if (data.Result != null && data.Result.Count != 0)
                        {
                            // All related credit cards (from the service 'GetAllRelatedCreditCardInOneCustNo') are returned as a set of "cardType", "cardNo", "creditLinePerCard"
                            foreach (StringDictionary entry in data.Result)
                            {
                                CreditCardInformation information = CreditCardService.RetrieveCreditCardDetail(entry["cardNo"], entry["cardType"]);
                                transaction.CreditCards.Add(information);
                                CreditCardCurrentTransaction currentTrx = RetrieveCreditCardCurrentTransactions(entry["cardNo"]);
                                foreach (CreditCardTransaction trx in currentTrx.Transactions)
                                {
                                    transaction.Transactions.Add(trx);
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
            }

            return(transaction);
        }
Example #12
0
 public CreditCardViewModel(CreditCardModel creditCardModel, CreditCardService creditCardService)
 {
     _creditCardModel   = creditCardModel;
     _originalCardModel = creditCardModel.Clone();
     _creditCardService = creditCardService;
 }
 public CardInfoController()
 {
     _creditService = ServiceFactory.getCreditService();
 }
Example #14
0
        public static CreditCardOutstandingTransaction OutstandingTransactions(Params request)
        {
            CreditCardOutstandingTransaction transaction = new CreditCardOutstandingTransaction();

            try
            {
                if (request.Parameter.ContainsKey("cardNo"))
                {
                    string cardNo = request.Parameter["cardNo"];
                    CreditCardInformation information = CreditCardService.RetrieveCreditCardDetail(cardNo, CreditCardService.RetrieveCreditCardType(cardNo));
                    transaction.CustomerNo = information.CustomerNo;
                    transaction.CreditCards.Add(information);
                    RetrieveCreditCardOutstandingTransactions(cardNo, transaction);
                }
                else if (request.Parameter.ContainsKey("custNo"))
                {
                    Params param = new Params()
                    {
                        Parameter = new Dictionary <string, string>()
                    };
                    param.RequestTransType = "GetAllRelatedCreditCardInOneCustNo";
                    param.Parameter.Add("custNo", request.Parameter["custNo"]);
                    param.WSDL = "AllRelatedDetail";
                    ESBData cardData = EAI.RetrieveESBData(param);
                    transaction.CustomerNo = request.Parameter["custNo"];

                    if (cardData.Result != null && cardData.Result.Count != 0)
                    {
                        foreach (StringDictionary entry in cardData.Result)
                        {
                            string cardno = entry["cardNo"];
                            if (!string.IsNullOrEmpty(cardno))
                            {
                                CreditCardInformation information = CreditCardService.RetrieveCreditCardDetail(cardno, entry["cardType"]);
                                transaction.CreditCards.Add(information);
                                RetrieveCreditCardOutstandingTransactions(cardno, transaction);
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
            }
            return(transaction);
        }
 public PaymentFacade(PaymentMachineService paymentMachineService, CreditCardService creditCardService)
 {
     _paymentMachineService = paymentMachineService;
     _creditCardService     = creditCardService;
 }
Example #16
0
 public void Setup()
 {
     _creditCardService = new CreditCardService();
 }
Example #17
0
        private CreditCardViewModel SetCreditCardViewModel(CreditCardService service)
        {
            if (!_transientCardEntry)
             {
            var vm = service.GetCreditCard(int.Parse(PaymentSourceCombo.SelectedValue));
            vm.ReceiptEmailAddressCsv = EmailReceiptTextBox.Text.Trim();
            return vm;
             }

             var cardProfile = service.CreateNew();
             cardProfile.CreditCardNumber = m_txtCreditCardNumber.Text;
             cardProfile.CardVerificationCode = m_txtCreditCardSecurityCode.Text;
             cardProfile.ExpirationMonth = m_cboCreditCardExpireMonth.SelectedValue;
             cardProfile.ExpirationYear = m_cboCreditCardExpireYear.SelectedValue;
             cardProfile.ReceiptEmailAddressCsv = m_txtEmail.Text;
             cardProfile.CardType = m_cboCreditCardType.SelectedItem.Text;
             cardProfile.FirstName = m_txtFirstName.Text;
             cardProfile.LastName = m_txtLastName.Text;
             cardProfile.CompanyName = CompanyNameText.Text;
             return cardProfile;
        }
        //Complete
        public bool CompleteTransaction(Job job, ActivityLogAddRequest add)
        {
            bool success = false;

            List <ActivityLog> list = _ActivityLogService.GetByJobId(add.JobId);

            foreach (var activity in list)
            {
                int currentStatus = activity.TargetValue;

                if (currentStatus == (int)JobStatus.BringgOnTheWay)
                {
                    _timeCreated = activity.IdCreated;
                }
                if (currentStatus == (int)JobStatus.BringgDone)
                {
                    _timeCompleted = activity.IdCreated;
                }
            }
            TimeSpan timeDifference = _timeCompleted.Subtract(_timeCreated);
            double   toMinutes      = timeDifference.TotalMinutes;

            CreditCardService cardService      = new CreditCardService();
            PaymentRequest    payment          = new PaymentRequest();
            BrainTreeService  brainTreeService = new BrainTreeService();

            List <string> Slugs = new List <string>();

            Slugs.Add("base-price");
            Slugs.Add("price-per-minute");
            Slugs.Add("minimum-job-duration");
            Slugs.Add("website-pricing-model");

            Dictionary <string, WebsiteSettings> dict = WebsiteSettingsServices.getWebsiteSettingsDictionaryBySlug(job.WebsiteId, Slugs);

            WebsiteSettings pricingModel = (dict["website-pricing-model"]);
            WebsiteSettings basePrice    = (dict["base-price"]);
            WebsiteSettings pricePerMin  = (dict["price-per-minute"]);
            WebsiteSettings jobDuration  = (dict["minimum-job-duration"]);

            // - Switch statement to calculate service cost depending on the website's pricing model

            int pricingModelValue = Convert.ToInt32(pricingModel.SettingsValue);

            switch (pricingModelValue)
            {
            case 1:
                _basePrice  = Convert.ToDouble(basePrice.SettingsValue);
                _totalPrice = _basePrice;
                break;

            case 2:
                _webPrice       = Convert.ToDouble(pricePerMin.SettingsValue);
                _minJobDuration = Convert.ToDouble(jobDuration.SettingsValue);

                if (toMinutes <= _minJobDuration)
                {
                    _totalPrice = _webPrice * _minJobDuration;
                }
                else
                {
                    _totalPrice = _webPrice * toMinutes;
                }

                break;

            case 3:
                _webPrice   = Convert.ToDouble(pricePerMin.SettingsValue);
                _basePrice  = Convert.ToDouble(basePrice.SettingsValue);
                _totalPrice = _webPrice + _basePrice;
                break;
            }


            JobsService.UpdateJobPrice(add.JobId, _totalPrice);

            if (job.UserId != null)
            {
                payment.UserId = job.UserId;
            }
            else
            {
                payment.UserId = job.Phone;
            }

            payment.ExternalCardIdNonce = job.PaymentNonce;
            payment.ItemCost            = (decimal)_totalPrice;

            String TokenHash = _UserProfileService.GetTokenHashByUserId(job.UserId);
            Guid   TokenGuid;

            Guid.TryParse(TokenHash, out TokenGuid);


            //This section was added by a team member
            if (TokenHash != null)
            {
                bool TokenUsed = TokenService.isTokenUsedReferral(TokenHash);

                //then find the user who referred userB
                //second service: get the userId of userA by using the tokenhash of userB
                //take User B's email and find the user id of the person who referred them (userA) and
                //use the [dbo].[Token_SelectByUserIdAndTokenType] and take UserId from the stored proc

                //[dbo].[Token_GetByGuid]

                //NOTE: User A is the initial friend who referred User B.

                Token GetUserA = TokenService.userGetByGuid(TokenGuid);

                string    UserAId        = GetUserA.UserId;
                int       CouponReferral = GetUserA.TokenType;
                TokenType referral       = (TokenType)CouponReferral;                      //parsing the int into an enum

                if (UserAId != null && referral == TokenType.Invite && TokenUsed == false) //if this user was referred from a friend && that referral coupon type  is 3 && if that coupon is not used, do the thing
                {
                    //give User A a credit of 25 dollars
                    CouponsDomain userCoupon = TokenService.GetReferralTokenByGuid(TokenHash);

                    UserCreditsRequest insertUserACredits = new UserCreditsRequest();
                    insertUserACredits.Amount          = userCoupon.CouponValue;
                    insertUserACredits.TransactionType = "Add";
                    insertUserACredits.UserId          = UserAId;
                    //_CreditsService.InsertUserCredits(insertUserACredits); // get int value for it and plug it ino the targetValue in activitylogrequest
                    int forTargetValue = _CreditsService.InsertUserCredits(insertUserACredits);


                    //then update the activity log for USER A to tell them that their friend completed their first order and that they were rewarded credits
                    ActivityLogAddRequest addCreditFriend = new ActivityLogAddRequest();

                    addCreditFriend.ActivityType = ActivityTypeId.CreditsFriend;
                    addCreditFriend.JobId        = job.Id;
                    addCreditFriend.TargetValue  = forTargetValue;
                    addCreditFriend.RawResponse  = Newtonsoft.Json.JsonConvert.SerializeObject(insertUserACredits);
                    _ActivityLogService.Insert(UserAId, addCreditFriend);

                    //update user B's activity log to show that they used the credits for their first payment
                    ActivityLogAddRequest addCredit = new ActivityLogAddRequest();

                    addCredit.ActivityType = ActivityTypeId.Credits;
                    addCredit.JobId        = job.Id;
                    addCredit.TargetValue  = forTargetValue;
                    addCredit.RawResponse  = Newtonsoft.Json.JsonConvert.SerializeObject(insertUserACredits);
                    _ActivityLogService.Insert(UserAId, addCredit);
                }
            }

            bool successpay = AdminPaymentService(payment, job.Id);

            if (successpay)
            {
                JobsService.UpdateJobStatus(JobStatus.Complete, job.ExternalJobId);

                ActivityLogAddRequest log = new ActivityLogAddRequest();
                log.JobId        = job.Id;
                log.TargetValue  = (int)JobStatus.Complete;
                log.ActivityType = ActivityTypeId.BringgTaskStatusUpdated;

                _ActivityLogService.Insert((job.UserId == null) ? job.Phone : job.UserId, log);
            }
            else
            {
                success = false;
            }

            return(success);
        }
        //BrainTree Customer Creation for maybe if GUEST wants to become member before Checkout.
        public bool CreateCustomerTransaction(CustomerPaymentRequest model)
        {
            //get user id with currentuserId
            string gotUserId = UserService.GetCurrentUserId();

            model.UserId = gotUserId;

            //Grab email from UserProfileService
            UserProfile userObject = _UserProfileService.GetUserById(model.UserId);

            string userEmail = userObject.Email;

            //Add the new card nonce & info into credit cards table
            UserCreditCards CardModel = new UserCreditCards();

            CardModel.UserId = model.UserId;
            CardModel.ExternalCardIdNonce = model.ExternalCardIdNonce;
            CardModel.Last4DigitsCC       = model.Last4DigitsCC;
            CardModel.CardType            = model.CardType;
            CreditCardService NewCardService = new CreditCardService();

            NewCardService.creditCardInsertModel(CardModel);

            int currentTransactionId = 0;

            //Post first Transaction log before result
            currentTransactionId = _TransactionLogService.BillingTransactionInsert(model);

            bool DuplicateBool = false;

            bool.TryParse(ConfigService.DuplicatePaymentMethod, out DuplicateBool);

            bool VerifyBool = false;

            bool.TryParse(ConfigService.VerifyCard, out VerifyBool);

            //create transaction and create customer in braintree system
            //***NEED TO ADD THE JOB_ID AS WELL LATER***
            TransactionRequest request = new TransactionRequest
            {
                Amount             = model.ItemCost,
                PaymentMethodNonce = model.ExternalCardIdNonce,
                Customer           = new CustomerRequest
                {
                    Id        = model.UserId,
                    FirstName = model.FirstName,
                    LastName  = model.LastName,
                    Email     = userEmail,

                    CreditCard = new CreditCardRequest
                    {
                        Options = new CreditCardOptionsRequest
                        {
                            FailOnDuplicatePaymentMethod = DuplicateBool,
                            VerifyCard = VerifyBool
                        }
                    }
                },
                Options = new TransactionOptionsRequest
                {
                    SubmitForSettlement   = true,
                    StoreInVaultOnSuccess = true,
                }
            };
            Result <Transaction> result = _Gateway.Transaction.Sale(request);

            //serialize the whole result object for backup purposes
            var transactionJson = new JavaScriptSerializer().Serialize(result);

            //Instantiate values into Transaction Log Model
            BillingTransactionLog LogModel = new BillingTransactionLog();

            LogModel.Id          = currentTransactionId;
            LogModel.RawResponse = transactionJson;

            //if else for whether the payment was successful or not
            if (result.Message == null && result.Errors == null)
            {
                //Instatiate Success Values
                LogModel.AmountConfirmed    = result.Target.Amount;
                LogModel.TransactionId      = result.Target.Id;
                LogModel.CardExpirationDate = result.Target.CreditCard.ExpirationDate;
                LogModel.CardLastFour       = result.Target.CreditCard.LastFour;

                ActivityLogRequest Activity = new ActivityLogRequest();

                Activity.ActivityType = ActivityTypeId.MadePayment;

                _ActivityLogService.InsertActivityToLog(model.UserId, Activity);



                return(_TransactionLogService.TransactionLogUpdateSuccess(LogModel));
            }
            else
            {
                //Instatiate Error Values
                LogModel.ErrorCode = result.Message;

                bool response = _TransactionLogService.TransactionLogUpdateError(LogModel);
                throw new System.ArgumentException(result.Message, "CreditCard");
            }
        }
 public CreditCardController(CreditCardService CreditCardService, ApplicationDbContext context)
 {
     _CreditCardService = CreditCardService;
     _context           = context;
 }
 protected string GetCardAlias()
 {
     var creditCardService = new CreditCardService(m_oIARequestEstimate.IARequest.MPUserID, MemberProtect, DataAccess, ApplicationContext.SiteProperites);
      var cardProfile = creditCardService.GetCreditCard(m_oIARequestEstimate.IARequest.IACustomerCreditCardID);
      return cardProfile != null ? cardProfile.Alias : string.Empty;
 }