Пример #1
0
        private async Task<Dictionary<string, ActionModel>> GetCostActions(UserIdentity userIdentity,
            Cost cost, CostStageRevision costStageRevision, CostUser user)
        {
            var isCostNeverSubmitted = costStageRevision.Status == CostStageRevisionStatus.Draft && costStageRevision.Name == CostStageConstants.OriginalEstimate;

            var stageDetails = JsonConvert.DeserializeObject<PgStageDetailsForm>(costStageRevision.StageDetails?.Data);
            var costUser = new
            {
                isApprover = user.UserUserGroups.Any(uug => uug.UserGroup.ObjectId == cost.Id && uug.UserGroup.Role.Name == Roles.CostApprover),
                isAdmin = user.UserUserGroups.Any(x => x.UserGroup.Role.Name == Roles.ClientAdmin && x.UserGroup.ObjectId == userIdentity.ModuleId),
                authLimit = user.ApprovalLimit,
                isFinanceManager = user.UserBusinessRoles.Any(ubr => ubr.BusinessRole != null && ubr.BusinessRole.Key == Constants.BusinessRole.FinanceManager && (ubr.ObjectId != null || ubr.Labels.Contains(stageDetails.SmoName)))
            };

            var purchaseOrderResponse = _customObjectDataService
                .GetCustomData<PgPurchaseOrderResponse>(costStageRevision.CustomObjectData, CustomObjectDataKeys.PgPurchaseOrderResponse);

            // current user is IPM user and is approved
            var userIsIPMAndApproved = costStageRevision.Approvals
                .Any(s => s.ApprovalMembers.Any(a => a.MemberId == userIdentity.Id && !a.IsExternal && a.Status == ApprovalStatus.Approved));

            var isLatestRevision = cost.LatestCostStageRevisionId == costStageRevision.Id;

            var paymentBelowAuthLimit = true;
            decimal costTotal = 0;

            if (cost.Status != CostStageRevisionStatus.Draft && costUser.authLimit.HasValue)
            {
                costTotal = costStageRevision.CostLineItems.Sum(cli => cli.ValueInDefaultCurrency);
                paymentBelowAuthLimit = costUser.authLimit.Value >= costTotal;
            }

            var actionRule = new PgActionRule
            {
                CostStage = costStageRevision.CostStage.Key,
                Status = costStageRevision.Status.ToString(),
                IsRevision = RevisionStages.Contains(costStageRevision.CostStage.Key),
                IsOwner = cost.OwnerId.Equals(userIdentity.Id),
                IsApprover = costUser.isApprover,
                HasPONumber = !string.IsNullOrEmpty(purchaseOrderResponse?.PoNumber),
                NeverSubmitted = isCostNeverSubmitted,
                HasExternalIntegration = cost.IsExternalPurchases,
                CostStageTotal = costTotal,
                CostTotalBelowAuthLimit = paymentBelowAuthLimit,
                IsAdmin = costUser.isAdmin,
                UserIsIPMAndApproved = userIsIPMAndApproved,
                UserIsFinanceManager = costUser.isFinanceManager,
                IsLatestRevision = isLatestRevision
            };

            var actions = await GetActions(actionRule);
            return actions;
        }
Пример #2
0
        private Dictionary <string, ActionModel> GetActions(PgActionRule rule, IEnumerable <CompiledRule <PgActionRule> > rules)
        {
            var matchFunc = new Func <PgActionRule, dataAccess.Entity.Rule, PgActionRuleDefinition>((t, r) =>
                                                                                                    (PgActionRuleDefinition)JsonConvert.DeserializeObject(r.Definition, typeof(PgActionRuleDefinition))
                                                                                                    );

            var aggregator = new Func <PgActionRuleDefinition, PgActionRuleDefinition, PgActionRuleDefinition>((acc, r) =>
            {
                acc.Actions.AddRange(r.Actions);
                return(acc);
            });

            _ruleService.TryMatchRule(rules, rule, matchFunc, aggregator, out var definition);

            return(definition?.Actions.ToDictionary(a => a, a => new ActionModel
            {
                Key = (CostAction)Enum.Parse(typeof(CostAction), a)
            }) ?? new Dictionary <string, ActionModel>());
        }
Пример #3
0
        private async Task<Dictionary<string, ActionModel>> GetActions(PgActionRule rule)
        {
            var rules = await _ruleService.GetCompiledByRuleType<PgActionRule>(RuleType.Action);
            var matchFunc = new Func<PgActionRule, dataAccess.Entity.Rule, PgActionRuleDefinition>((t, r) =>
                (PgActionRuleDefinition)JsonConvert.DeserializeObject(r.Definition, typeof(PgActionRuleDefinition))
            );

            var aggregator = new Func<PgActionRuleDefinition, PgActionRuleDefinition, PgActionRuleDefinition>((acc, r) =>
            {
                acc.Actions.AddRange(r.Actions);
                return acc;
            });

            _ruleService.TryMatchRule(rules, rule, matchFunc, aggregator, out var definition);

            return definition?.Actions.ToDictionary(a => a, a => new ActionModel
            {
                Key = (CostAction)Enum.Parse(typeof(CostAction), a)
            }) ?? new Dictionary<string, ActionModel>();
        }
Пример #4
0
        /// <summary>
        /// Get corresponding actions of user on cost
        /// </summary>
        /// <param name="userIdentity">current user</param>
        /// <param name="cost">cost must have its data - dont need any other related table</param>
        /// <param name="costStageRevision">revision must have data of StageDetails / CustomObjectData / Approvals / CostLineItems / Cost Stage tables</param>
        /// <param name="revisionsCount">total number of revisions in the same stage</param>
        private async Task <Dictionary <string, ActionModel> > GetCostActions(UserIdentity userIdentity, Cost cost, CostStageRevision costStageRevision, int revisionsCount)
        {
            var actionRules = await _ruleService.GetCompiledByRuleType <PgActionRule>(RuleType.Action);

            var stageDetails = JsonConvert.DeserializeObject <PgStageDetailsForm>(costStageRevision.StageDetails.Data);
            var smoName      = stageDetails.SmoName;

            var costUser = await _efContext.CostUser
                           .Where(x => x.Id == userIdentity.Id)
                           .Select(cu => new
            {
                isApprover       = cu.UserUserGroups.Any(uug => uug.UserGroup.ObjectId == cost.Id && uug.UserGroup.Role.Name == Roles.CostApprover),
                isAdmin          = cu.UserUserGroups.Any(x => x.UserGroup.Role.Name == Roles.ClientAdmin && x.UserGroup.ObjectId == userIdentity.ModuleId),
                authLimit        = cu.ApprovalLimit,
                isFinanceManager = cu.UserBusinessRoles.Any(ubr => ubr.BusinessRole != null && ubr.BusinessRole.Key == Constants.BusinessRole.FinanceManager && (ubr.ObjectId != null || ubr.Labels.Contains(smoName)))
            })
                           .AsNoTracking()
                           .FirstOrDefaultAsync();

            var dataItem = costStageRevision.CustomObjectData.FirstOrDefault(i => i.Name == CustomObjectDataKeys.PgPurchaseOrderResponse);

            var purchaseOrderResponse = dataItem != null
                ? JsonConvert.DeserializeObject <PgPurchaseOrderResponse>(dataItem.Data)
                : new PgPurchaseOrderResponse();

            // current user is IPM user and is approved
            var userIsIPMAndApproved = costStageRevision.Approvals
                                       .Any(s => s.ApprovalMembers.Any(a => a.MemberId == userIdentity.Id && !a.IsExternal && a.Status == ApprovalStatus.Approved));

            var isLatestRevision = cost.LatestCostStageRevisionId == costStageRevision.Id;

            var     paymentBelowAuthLimit = true;
            decimal costTotal             = 0;

            // ADC-812, ADC-820
            if (cost.Status != CostStageRevisionStatus.Draft && costUser.authLimit.HasValue)
            {
                costTotal             = costStageRevision.CostLineItems.Sum(cli => cli.ValueInDefaultCurrency);
                paymentBelowAuthLimit = costUser.authLimit.Value >= costTotal;
            }

            var actionRule = new PgActionRule
            {
                CostStage               = costStageRevision.CostStage.Key,
                Status                  = costStageRevision.Status.ToString(),
                IsRevision              = Constants.RevisionStages.Contains(costStageRevision.CostStage.Key),
                IsOwner                 = cost.OwnerId.Equals(userIdentity.Id),
                IsApprover              = costUser.isApprover,
                HasPONumber             = !string.IsNullOrEmpty(purchaseOrderResponse?.PoNumber),
                NeverSubmitted          = revisionsCount == 1 && costStageRevision.Status == CostStageRevisionStatus.Draft,
                HasExternalIntegration  = cost.IsExternalPurchases,
                CostStageTotal          = costTotal,
                CostTotalBelowAuthLimit = paymentBelowAuthLimit,
                IsAdmin                 = costUser.isAdmin,
                UserIsIPMAndApproved    = userIsIPMAndApproved,
                UserIsFinanceManager    = costUser.isFinanceManager,
                IsLatestRevision        = isLatestRevision
            };

            var actions = GetActions(actionRule, actionRules);

            return(actions);
        }