public async Task <string> InsertAsync(CampaignCompletion campaignCompletion)
        {
            var id = (await _campaignCompletionRepository.InsertAsync(campaignCompletion)).ToString("D");

            campaignCompletion.Id = id;

            return(id);
        }
 public async Task UpdateAsync(CampaignCompletion campaignCompletion)
 {
     using (var context = _msSqlContextFactory.CreateDataContext())
     {
         var entity = _mapper.Map <CampaignCompletionEntity>(campaignCompletion);
         context.CampaignCompletionEntities.Update(entity);
         await context.SaveChangesAsync();
     }
 }
        public async Task <Guid> InsertAsync(CampaignCompletion campaignCompletion)
        {
            using (var context = _msSqlContextFactory.CreateDataContext())
            {
                var entity = _mapper.Map <CampaignCompletionEntity>(campaignCompletion);

                context.Add(entity);

                await context.SaveChangesAsync();

                return(entity.Id);
            }
        }
        public async Task IncreaseCompletionCountAsync(CampaignCompletion campaignCompletion, Domain.Models.Campaign campaign, IEnumerable <ConditionCompletion> conditionCompletions)
        {
            campaignCompletion.CampaignCompletionCount++;

            if (campaignCompletion.CampaignCompletionCount >= campaign.CompletionCount)
            {
                campaignCompletion.IsCompleted = true;
            }

            // Delete CONDITION tracking because they needs to be reset before next campaign completion
            await _conditionCompletion.DeleteAsync(conditionCompletions);

            // Keep track of CAMPAIGN completion
            await _campaignCompletionRepository.UpdateAsync(campaignCompletion);
        }
        private async Task ProcessCampaignAsync(
            string customerId,
            string partnerId,
            string locationId,
            IReadOnlyDictionary <string, string> data,
            string conditionType,
            Domain.Models.Campaign campaign,
            Guid operationId)
        {
            var campaignCompletion = await _campaignCompletionService.GetByCampaignAsync(campaign.Id, customerId);

            if (campaignCompletion == null)
            {
                campaignCompletion = new CampaignCompletion
                {
                    CampaignCompletionCount = 0,
                    CampaignId  = campaign.Id,
                    CustomerId  = customerId,
                    IsCompleted = false
                };

                await _campaignCompletionService.InsertAsync(campaignCompletion);
            }

            if (!campaignCompletion.IsCompleted)
            {
                await PublishParticipationEventAsync(campaign.Id, customerId);

                var campaignModel = _mapper.Map <Domain.Models.Campaign>(campaign);

                var conditions = campaignModel.Conditions
                                 .Where(c => c.BonusType.Type == conditionType)
                                 .ToList();

                await ProcessConditionsForCustomerAsync(
                    customerId,
                    partnerId,
                    locationId,
                    campaignModel.Id,
                    conditions,
                    data,
                    operationId);

                await ProcessCampaignForCustomerAsync(campaignModel, campaignCompletion, operationId, data);
            }
        }
        private async Task ProcessCampaignForCustomerAsync(MAVN.Service.BonusEngine.Domain.Models.Campaign campaign,
                                                           CampaignCompletion campaignCompletion, Guid operationId, IReadOnlyDictionary <string, string> data)
        {
            var customerId = campaignCompletion.CustomerId;
            var campaignId = campaign.Id;

            var conditionCompletions = await _conditionCompletionService
                                       .GetConditionCompletionsAsync(customerId, campaignId);

            if (IsCampaignCompleted(conditionCompletions, campaign) == false)
            {
                return;
            }

            var reward = await _bonusCalculatorService.CalculateRewardAmountAsync(campaign, customerId, conditionCompletions);

            var bonusOperation = new BonusOperation
            {
                CustomerId          = customerId,
                CampaignId          = campaignId,
                ExternalOperationId = operationId,
                Reward             = reward,
                TimeStamp          = DateTime.UtcNow,
                BonusOperationType = BonusOperationType.CampaignReward
            };

            if (data.TryGetValue(ReferralId, out string referralId))
            {
                bonusOperation.ReferralId = referralId;
            }

            await _bonusOperationService.AddBonusOperationAsync(bonusOperation);

            _log.Info("Customer completed all condition in campaign.",
                      context: $"operationId: {operationId}; campaignId: {campaignId}; customerId: {customerId}");

            await _campaignCompletionService.IncreaseCompletionCountAsync(campaignCompletion, campaign,
                                                                          conditionCompletions);
        }
Example #7
0
        private void CreateConditionTestData()
        {
            BonusType = new BonusType
            {
                Type        = BonusTypeName,
                DisplayName = BonusTypeName
            };

            ConditionModel = new Condition()
            {
                CampaignId      = CampaignId,
                CompletionCount = 1,
                BonusType       = BonusType,
                Id = ConditionId,
                ImmediateReward = 10
            };

            ConditionModels = new List <Condition>()
            {
                ConditionModel
            };

            NewConditionCompletion = new ConditionCompletion
            {
                CustomerId   = CustomerId,
                ConditionId  = ConditionId,
                Id           = ConditionCompletionsId,
                CurrentCount = 0,
                IsCompleted  = false
            };

            ConditionCompletions = new List <ConditionCompletion>();

            NewConditionBonusOperation = new BonusOperation
            {
                CustomerId         = CustomerId,
                Reward             = ConditionModel.ImmediateReward,
                BonusOperationType = BonusOperationType.CampaignReward
            };

            CampaignModel = new CampaignModel()
            {
                Name            = "SignUp Campaign",
                Reward          = 20,
                Id              = CampaignId,
                CompletionCount = 1,
                Conditions      = new List <Condition>()
                {
                    ConditionModel
                }
            };

            CampaignModels = new List <CampaignModel>()
            {
                CampaignModel
            };

            CampaignCompletion = new CampaignCompletion()
            {
                CustomerId = CustomerId,
                CampaignId = CampaignId,
                CampaignCompletionCount = 0
            };

            CampaignCompletions = new List <CampaignCompletion>()
            {
                CampaignCompletion
            };

            NewCampaignBonusOperation = new BonusOperation
            {
                CustomerId         = CustomerId,
                Reward             = CampaignModel.Reward,
                BonusOperationType = BonusOperationType.CampaignReward
            };
        }