public DocumentToRepositoryValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser)
        {
            RuleFor(o => o)
            .Cascade(CascadeMode.StopOnFirstFailure)
            .MustAsync(async(context, cancellationToken) =>
            {
                _groupMember = await alfrescoHttpClient.GetGroupMembers(SpisumNames.Groups.RepositoryGroup, ImmutableList <Parameter> .Empty
                                                                        .Add(new Parameter(AlfrescoNames.Headers.Where, AlfrescoNames.MemberType.Group, ParameterType.QueryString)));
                _groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);

                return(_groupMember != null && _groupPaging != null);
            })
            .WithName(x => nameof(x.Group))
            .WithMessage("Something went wrong with alfresco server.")
            .DependentRules(() =>
            {
                RuleFor(x => x)
                .Must(y => _groupPaging?.List?.Entries?.Any(q => q.Entry.Id == identityUser.RequestGroup) ?? false)
                .WithName(x => "Group")
                .WithMessage($"User isn't member of group {identityUser.RequestGroup}.");

                RuleFor(x => x)
                .Must(y => _groupMember?.List?.Entries?.Any(q => q.Entry.Id == y.Group) ?? false)
                .WithName(x => "Group")
                .WithMessage(x => $"Group {x.Group} does not exists.");
            });
        }
        public DocumentBorrowValidator(IAlfrescoHttpClient alfrescoHttpClient,
                                       IIdentityUser identityUser,
                                       IAlfrescoConfiguration alfrescoConfiguration,
                                       ISimpleMemoryCache simpleMemoryCache,
                                       ISystemLoginService systemLoginService)
        {
            var adminHttpClient = new AlfrescoHttpClient(alfrescoConfiguration, new AdminAuthentification(simpleMemoryCache, alfrescoConfiguration, systemLoginService));

            _identityUser = identityUser;

            RuleFor(o => o)
            .Cascade(CascadeMode.StopOnFirstFailure)
            .MustAsync(async(context, cancellationToken) =>
            {
                _nodeEntry = await alfrescoHttpClient.GetNodeInfo(context.NodeId, ImmutableList <Parameter> .Empty
                                                                  .Add(new Parameter(AlfrescoNames.Headers.Include, AlfrescoNames.Includes.Path, ParameterType.QueryString)));

                var documentProperties = _nodeEntry?.Entry?.Properties?.As <JObject>().ToDictionary();
                _borrowedUser          = documentProperties.GetNestedValueOrDefault(SpisumNames.Properties.Borrower)?.ToString();

                _groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);

                _groupRepository = await alfrescoHttpClient.GetGroupMembers(SpisumNames.Groups.RepositoryGroup,
                                                                            ImmutableList <Parameter> .Empty.Add(new Parameter(AlfrescoNames.Headers.Where, AlfrescoNames.MemberType.Group, ParameterType.QueryString)));

                _groupPagingNextOwner = await adminHttpClient.GetPersonGroups(context.Body.User);

                return(_nodeEntry?.Entry?.Id != null && _groupPaging != null && _groupPagingNextOwner != null && _groupRepository != null);
            })
            .WithName(x => nameof(x.NodeId))
            .WithMessage("Something went wrong with alfresco server.")
            .DependentRules(() =>
            {
                RuleFor(x => x)
                .Must(y =>
                {
                    return(_groupPagingNextOwner?.List?.Entries?.Any(q => q.Entry.Id == y.Body.Group) ?? false);
                })
                .WithName(x => "User")
                .WithMessage("User isn't member of the Group.");

                RuleFor(x => x)
                .Must(y =>
                {
                    return(_groupRepository?.List?.Entries?.Any(x => x.Entry.Id == identityUser.RequestGroup) ?? false);
                })
                .WithName(x => "User")
                .WithMessage("User isn't member of repository group");

                RuleFor(x => x)
                .Must(y => _groupPaging?.List?.Entries?.Any(q => q.Entry.Id == identityUser.RequestGroup) ?? false)
                .WithName(x => "Group")
                .WithMessage($"User isn't member of group {identityUser.RequestGroup}.");

                RuleFor(x => x.NodeId)
                .Must(x => _nodeEntry.Entry.NodeType == SpisumNames.NodeTypes.Document)
                .WithMessage($"NodeId must be type of {SpisumNames.NodeTypes.Document}.");

                RuleFor(x => x)
                .Must(x => _nodeEntry?.Entry?.Path?.Name?.StartsWith(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.RepositoryDocuments, StringComparison.OrdinalIgnoreCase) == true)
                .OnAnyFailure(x => throw new BadRequestException("Document must be in repository site."));

                RuleFor(x => x)
                .Must(x => string.IsNullOrWhiteSpace(_borrowedUser))
                .WithMessage("Document is already borrowed");
            });
        }
        public ShipmentUpdatePersonallyValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser, INodesService nodesService)
        {
            RuleFor(o => o)
            .Cascade(CascadeMode.StopOnFirstFailure)
            .MustAsync(async(context, cancellationToken) =>
            {
                _nodeEntry = await alfrescoHttpClient.GetNodeInfo(context.NodeId, ImmutableList <Parameter> .Empty
                                                                  .Add(new Parameter(AlfrescoNames.Headers.Include, AlfrescoNames.Includes.Path, ParameterType.QueryString)));
                _nodeParents = await nodesService.GetParentsByAssociation(context.NodeId, new List <string>
                {
                    SpisumNames.Associations.ShipmentsCreated,
                    SpisumNames.Associations.ShipmentsToReturn,
                    SpisumNames.Associations.ShipmentsToDispatch
                });
                _groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);

                if (_nodeParents?.Any(x => x?.Entry?.Association?.AssocType == SpisumNames.Associations.ShipmentsToDispatch) ?? false)
                {
                    _groupToDispatch = await alfrescoHttpClient.GetGroupMembers(SpisumNames.Groups.DispatchGroup,
                                                                                ImmutableList <Parameter> .Empty.Add(new Parameter(AlfrescoNames.Headers.Where, AlfrescoNames.MemberType.Group, ParameterType.QueryString)));
                }

                return(_nodeEntry?.Entry?.Id != null && _groupPaging != null && _nodeParents != null);
            })
            .WithName(x => nameof(x.NodeId))
            .WithMessage("Something went wrong with alfresco server.")
            .DependentRules(() =>
            {
                RuleFor(x => x)
                .Must(y => _groupPaging?.List?.Entries?.Any(q => q.Entry.Id == identityUser.RequestGroup) ?? false)
                .WithName(x => "Group")
                .WithMessage($"User isn't member of group {identityUser.RequestGroup}.");

                RuleFor(x => x.NodeId)
                .Must(x => _nodeEntry.Entry.NodeType == SpisumNames.NodeTypes.ShipmentPersonally)
                .WithMessage(x => $"Provided nodeId must be NodeType {SpisumNames.NodeTypes.ShipmentPersonally}");

                RuleFor(x => x)
                .Must(y => _nodeParents?.Any(q => q.Entry.NodeType == SpisumNames.NodeTypes.Document || q.Entry.NodeType == SpisumNames.NodeTypes.File) ?? false)
                .WithName(x => "Parent")
                .WithMessage($"Provided shipment does not have a parent type of {SpisumNames.NodeTypes.Document} or {SpisumNames.NodeTypes.File}");

                RuleFor(x => x)
                .Must(y => CheckDispatchGroup(identityUser.RequestGroup))
                .WithMessage(x => "Dispatch group")
                .WithMessage($"Requested group in not part of {SpisumNames.Groups.DispatchGroup}");
            });

            RuleFor(x => x.Body.Address1)
            .Must(x => CheckLength(x, 100))
            .When(x => x.Body != null)
            .WithMessage("Address1 is too long");

            RuleFor(x => x.Body.Address2)
            .Must(x => CheckLength(x, 100))
            .When(x => x.Body != null)
            .WithMessage("Address2 is too long");

            RuleFor(x => x.Body.Address3)
            .Must(x => CheckLength(x, 100))
            .When(x => x.Body != null)
            .WithMessage("Address3 is too long");

            RuleFor(x => x.Body.Address4)
            .Must(x => CheckLength(x, 100))
            .When(x => x.Body != null)
            .WithMessage("Address4 is too long");

            RuleFor(x => x.Body.AddressStreet)
            .Must(x => CheckLength(x, 100))
            .When(x => x.Body != null)
            .WithMessage("AddressStreet is too long");

            RuleFor(x => x.Body.AddressCity)
            .Must(x => CheckLength(x, 100))
            .When(x => x.Body != null)
            .WithMessage("AddressCity is too long");

            RuleFor(x => x.Body.AddressZip)
            .Must(x => CheckLength(x, 100))
            .When(x => x.Body != null)
            .WithMessage("AddressZip is too long");

            RuleFor(x => x.Body.AddressState)
            .Must(x => CheckLength(x, 100))
            .When(x => x.Body != null)
            .WithMessage("AddressState is too long");
        }
예제 #4
0
        public ShipmentUpdateEmailValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser, INodesService nodesService, IEmailHttpClient emailHttpClient)
        {
            RuleFor(o => o)
            .Cascade(CascadeMode.StopOnFirstFailure)
            .MustAsync(async(context, cancellationToken) =>
            {
                _nodeEntry = await alfrescoHttpClient.GetNodeInfo(context.NodeId, ImmutableList <Parameter> .Empty
                                                                  .Add(new Parameter(AlfrescoNames.Headers.Include, AlfrescoNames.Includes.Path, ParameterType.QueryString)));
                _nodeParents = await nodesService.GetParentsByAssociation(context.NodeId, new List <string>
                {
                    SpisumNames.Associations.ShipmentsCreated,
                    SpisumNames.Associations.ShipmentsToReturn,
                    SpisumNames.Associations.ShipmentsToDispatch
                });
                _groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);

                try { _accounts = await emailHttpClient.Accounts(); } catch { }


                if (_nodeParents?.Any(x => x?.Entry?.Association?.AssocType == SpisumNames.Associations.ShipmentsToDispatch) ?? false)
                {
                    _groupToDispatch = await alfrescoHttpClient.GetGroupMembers(SpisumNames.Groups.DispatchGroup,
                                                                                ImmutableList <Parameter> .Empty.Add(new Parameter(AlfrescoNames.Headers.Where, AlfrescoNames.MemberType.Group, ParameterType.QueryString)));
                }

                return(_nodeEntry?.Entry?.Id != null && _groupPaging != null && _nodeParents != null && _accounts != null);
            })
            .WithName(x => nameof(x.NodeId))
            .WithMessage("Something went wrong with alfresco server.")
            .DependentRules(() =>
            {
                RuleFor(x => x)
                .Must(y => _groupPaging?.List?.Entries?.Any(q => q.Entry.Id == identityUser.RequestGroup) ?? false)
                .WithName(x => "Group")
                .WithMessage($"User isn't member of group {identityUser.RequestGroup}.");

                RuleFor(x => x.NodeId)
                .Must(x => _nodeEntry.Entry.NodeType == SpisumNames.NodeTypes.ShipmentEmail)
                .WithMessage(x => $"Provided nodeId must be NodeType {SpisumNames.NodeTypes.ShipmentEmail}");

                RuleFor(x => x)
                .Must(y => _nodeParents?.Any(q => q.Entry.NodeType == SpisumNames.NodeTypes.Document) ?? false)
                .WithName(x => "Parent")
                .WithMessage($"Provided shipment does not have a parent type of {SpisumNames.NodeTypes.Document}");

                RuleFor(x => x)
                .Must(y => CheckDispatchGroup(identityUser.RequestGroup))
                .WithMessage(x => "Dispatch group")
                .WithMessage($"Requested group in not part of {SpisumNames.Groups.DispatchGroup}");

                RuleFor(x => x)
                .Must(x => _accounts.Count > 0)
                .WithMessage(x => "No email configuration on email server");

                RuleFor(x => x.Body.Sender)
                .Must(y => _accounts?.Any(x => x.Username == y) ?? false)
                .WithMessage(x => "Sender was not found in email configuration on email server");
            });

            RuleFor(x => x.Body.Recipient)
            .Must(x => EmailUtils.IsValidEmail(x))
            .When(x => x.Body != null)
            .WithName(x => "Recipient")
            .WithMessage("Recipient is not a valid email address");

            RuleFor(x => x.Body.Subject)
            .Must(x => CheckLength(x, 255))
            .When(x => x.Body != null)
            .WithName(x => "Subject")
            .WithMessage("Subject is too long");

            RuleFor(x => x.Body.Recipient)
            .Must(x => CheckLength(x, 254))
            .When(x => x.Body != null)
            .WithName(x => "Recipient")
            .WithMessage("Recipient is too long");

            RuleFor(x => x.Body.Components)
            .Must(y => y.Count > 0)
            .WithName(x => "Components")
            .WithMessage("Components cannot be empty");
        }
        public ShipmentUpdatePublishValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser, INodesService nodesService)
        {
            RuleFor(o => o)
            .Cascade(CascadeMode.StopOnFirstFailure)
            .MustAsync(async(context, cancellationToken) =>
            {
                _nodeEntry = await alfrescoHttpClient.GetNodeInfo(context.NodeId, ImmutableList <Parameter> .Empty
                                                                  .Add(new Parameter(AlfrescoNames.Headers.Include, AlfrescoNames.Includes.Path, ParameterType.QueryString)));
                _nodeParents = await nodesService.GetParentsByAssociation(context.NodeId, new List <string>
                {
                    SpisumNames.Associations.ShipmentsCreated,
                    SpisumNames.Associations.ShipmentsToReturn,
                    SpisumNames.Associations.ShipmentsToDispatch
                });
                _groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);

                if (_nodeParents?.Any(x => x?.Entry?.Association?.AssocType == SpisumNames.Associations.ShipmentsToDispatch) ?? false)
                {
                    _groupToDispatch = await alfrescoHttpClient.GetGroupMembers(SpisumNames.Groups.DispatchGroup,
                                                                                ImmutableList <Parameter> .Empty.Add(new Parameter(AlfrescoNames.Headers.Where, AlfrescoNames.MemberType.Group, ParameterType.QueryString)));
                }

                return(_nodeEntry?.Entry?.Id != null && _groupPaging != null && _nodeParents != null);
            })
            .WithName(x => nameof(x.NodeId))
            .WithMessage("Something went wrong with alfresco server.")
            .DependentRules(() =>
            {
                RuleFor(x => x)
                .Must(y => _groupPaging?.List?.Entries?.Any(q => q.Entry.Id == identityUser.RequestGroup) ?? false)
                .WithName(x => "Group")
                .WithMessage($"User isn't member of group {identityUser.RequestGroup}.");

                RuleFor(x => x.NodeId)
                .Must(x => _nodeEntry.Entry.NodeType == SpisumNames.NodeTypes.ShipmentPublish)
                .WithMessage(x => $"Provided nodeId must be NodeType {SpisumNames.NodeTypes.ShipmentPublish}");

                RuleFor(x => x)
                .Must(y => _nodeParents?.Any(q => q.Entry.NodeType == SpisumNames.NodeTypes.Document) ?? false)
                .WithName(x => "Parent")
                .WithMessage($"Provided shipment does not have a parent type of {SpisumNames.NodeTypes.Document}");

                RuleFor(x => x)
                .Must(y => CheckDispatchGroup(identityUser.RequestGroup))
                .WithName(x => "Dispatch group")
                .WithMessage($"Requested group in not part of {SpisumNames.Groups.DispatchGroup}");
            });

            RuleFor(x => x.Body.Components)
            .Must(y => y.Count > 0)
            .When(x => x.Body != null)
            .WithName(x => "Components")
            .WithMessage("Components cannot be empty");

            RuleFor(x => x.Body.DateFrom)
            .Must(y => y.HasValue && CompareDateTime(y.Value))
            .When(x => x.Body != null)
            .WithName(x => "DateFrom")
            .WithMessage("DateFrom cannot be in past");

            RuleFor(x => x.Body.Days)
            .Must(y => y.HasValue ? y.Value > 0 : true)
            .When(x => x.Body != null)
            .WithName(x => "Days")
            .WithMessage("Days must be greater than 0");

            RuleFor(x => x.Body.Note)
            .MaximumLength(255)
            .When(x => x.Body != null)
            .WithName(x => "Note")
            .WithMessage("Message cannot be longer than 255 characters");
        }