public ClaimsIdentity GenerateClaimsIdentityForUser(IIdentityUser user)
{
return(new ClaimsIdentity(new Claim[] {
new Claim(ClaimTypes.Name, user.UserName),
new Claim(ClaimTypes.NameIdentifier, user.Id)
}));
}
public FileChangeFileMarkValidator(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)));
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
return(_nodeEntry?.Entry?.Id != null && _groupPaging != 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.File)
.WithMessage($"NodeId must be type of {SpisumNames.NodeTypes.File}.");
});
}
public FileDocumentAddValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser)
{
RuleFor(o => o)
.Cascade(CascadeMode.StopOnFirstFailure)
.MustAsync(async(context, cancellationToken) =>
{
_nodeEntry = await alfrescoHttpClient.GetNodeInfo(context.NodeId);
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
return(_nodeEntry?.Entry?.Id != null && _groupPaging != 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.File)
.WithMessage(x => $"Provided nodeId must be NodeType {SpisumNames.NodeTypes.File}");
});
}
public CommentService(SnsdbContext snsdbContext,
IMapper mapper, IIdentityUser <int, LoginAuthModel> identityUser)
{
_snsdbContext = snsdbContext;
_mapper = mapper;
_identityUser = identityUser;
}
public SignerService(
ISignerClient signerClient,
ISimpleMemoryCache simpleMemoryCache,
IAlfrescoConfiguration alfrescoConfiguration,
IPersonService personService,
IIdentityUser identityUser,
IMapper mapper,
ITransactionHistoryService transactionHistoryService,
IAuditLogService auditLogService,
IRepositoryService repositoryService,
IAlfrescoHttpClient alfrescoHttpClient,
IPdfService pdfService,
ISystemLoginService systemLoginService
)
{
_signerClient = signerClient;
_simpleMemoryCache = simpleMemoryCache;
_alfrescoConfiguration = alfrescoConfiguration;
_personService = personService;
_identityUser = identityUser;
_mapper = mapper;
_transactionHistoryService = transactionHistoryService;
_auditLogService = auditLogService;
_repositoryService = repositoryService;
_alfrescoHttpClient = alfrescoHttpClient;
_pdfService = pdfService;
_systemLoginService = systemLoginService;
}
public DocumentForSignatureValidator(
IAlfrescoHttpClient alfrescoHttpClient,
IIdentityUser identityUser,
IAlfrescoConfiguration alfrescoConfiguration,
ISimpleMemoryCache simpleMemoryCache,
ISystemLoginService systemLoginService)
{
var adminHttpClient = new AlfrescoHttpClient(alfrescoConfiguration, new AdminAuthentification(simpleMemoryCache, alfrescoConfiguration, systemLoginService));
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)));
_groupPagingCurrentUser = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
_groupPagingNextOwner = await adminHttpClient.GetPersonGroups(context.Body.User);
return(_nodeEntry?.Entry?.Id != null && _groupPagingCurrentUser != null && _groupPagingNextOwner != null);
})
.WithName(x => nameof(x.NodeId))
.WithMessage("Something went wrong with alfresco server.")
.DependentRules(() =>
{
RuleFor(x => x)
.Must(y => _groupPagingCurrentUser?.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 => _groupPagingNextOwner?.List?.Entries?.Any(q => q.Entry.Id == $"{y.Body.Group}_Sign") ?? false)
.WithName(x => "Group")
.WithMessage("User for signing isn't member of group with postfix _Sign.");
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.Evidence, StringComparison.OrdinalIgnoreCase) == true)
.OnAnyFailure(x => throw new BadRequestException("Document must be in evidence site."));
RuleFor(x => x.NodeId)
.Must(x => _nodeEntry.Entry.Path.Name.Equals(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.EvidenceDocumentsForProcessing(identityUser.RequestGroup)) ||
_nodeEntry.Entry.Path.Name.Equals(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.EvidenceFilesDocumentsForProcessing(identityUser.RequestGroup)))
.WithMessage($"NodeId must be in path {SpisumNames.Paths.EvidenceDocumentsForProcessing(identityUser.RequestGroup)} or {SpisumNames.Paths.EvidenceFilesDocumentsForProcessing(identityUser.RequestGroup)}.");
});
RuleFor(x => x)
.Must(x => !string.IsNullOrEmpty(x?.Body?.User))
.When(x => x?.Body != null)
.WithName(x => nameof(x.Body.User))
.WithMessage("You have to fill user.");
RuleFor(x => x)
.Must(x => !string.IsNullOrEmpty(x?.Body?.Group))
.When(x => x?.Body != null)
.WithName(x => nameof(x.Body.Group))
.WithMessage("You have to fill group.");
}
#pragma warning disable 4014
public virtual async Task CreateAsync(TUser user)
{
IIdentityUser identityUser = user;
IDatabase db = Database;
ITransaction transaction = CreateTransaction();
if (string.IsNullOrEmpty(identityUser.Id))
{
identityUser.Id = (await db.StringIncrementAsync(UserIdKey)).ToString();
}
transaction.HashSetAsync
(
UserHashByIdKey,
new[]
{
new HashEntry(identityUser.Id, JsonConvert.SerializeObject(user))
}
);
transaction.HashSetAsync
(
UserHashByNameKey,
new[]
{
new HashEntry(user.UserName, identityUser.Id)
}
);
await transaction.ExecuteAsync();
}
public DocumentSettleCancelValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser 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)));
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
return(_nodeEntry?.Entry?.Id != null && _groupPaging != 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.Document)
.WithMessage(x => $"Provided nodeId must be NodeType {SpisumNames.NodeTypes.Document}");
RuleFor(x => x.NodeId)
.Must(x => _nodeEntry.Entry.Path.Name.Equals(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.EvidenceDocumentsProcessed(identityUser.RequestGroup)) ||
_nodeEntry.Entry.Path.Name.Equals(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.EvidenceFilesDocumentsProcessed(identityUser.RequestGroup)))
.WithMessage($"NodeId must be in path {SpisumNames.Paths.EvidenceDocumentsProcessed(identityUser.RequestGroup)} or {SpisumNames.Paths.EvidenceFilesDocumentsProcessed(identityUser.RequestGroup)}.");
});
RuleFor(x => x)
.Must(CheckReasonLength);
}
public DocumentController(
IAlfrescoHttpClient alfrescoHttpClient,
IAuditLogService auditLogService,
IComponentService componentService,
IDocumentService documentService,
IIdentityUser identityUser,
INodesService nodesService,
ISpisUmConfiguration spisUmConfiguration,
ITransactionHistoryService transactionHistory,
IShipmentsService shipmentsService,
IValidationService validationService,
IAlfrescoModelComparer alfrescoModelComparer,
ITranslateService translateService
)
{
_alfrescoHttpClient = alfrescoHttpClient;
_auditLogService = auditLogService;
_componentService = componentService;
_documentService = documentService;
_identityUser = identityUser;
_nodesService = nodesService;
_shipmentsService = shipmentsService;
_spisUmConfiguration = spisUmConfiguration;
_transactionHistory = transactionHistory;
_validationService = validationService;
_alfrescoModelComparer = alfrescoModelComparer;
_translateService = translateService;
}
public ShipmentReturnValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser)
{
RuleFor(o => o)
.Cascade(CascadeMode.StopOnFirstFailure)
.MustAsync(async(context, cancellationToken) =>
{
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
return(_groupPaging != null);
})
.WithName(x => nameof(x))
.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.Reason)
.MinimumLength(4)
.MaximumLength(30)
.WithName("Reason")
.WithMessage("Reason must be at least 4 chatacters long and maximum 30 characters");
}
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 ShipmentCancelValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser)
{
RuleFor(o => o)
.Cascade(CascadeMode.StopOnFirstFailure)
.MustAsync(async(context, cancellationToken) =>
{
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
await context.NodeIds.ForEachAsync(async x => { _nodeEntries.Add(await alfrescoHttpClient.GetNodeInfo(x)); });
return(_groupPaging != null && _nodeEntries?.Count != 0);
})
.WithName("Document")
.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 => _nodeEntries?.All(q => q.Entry.NodeType.StartsWith("ssl:shipment")) ?? false)
.WithName(x => "NodeIds")
.WithMessage("Not all provided nodes are type of shipment.");
});
}
public DocumentCreateValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser identityUser)
{
RuleFor(o => o)
.Cascade(CascadeMode.StopOnFirstFailure)
.MustAsync(async(context, cancellationToken) =>
{
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
return(_groupPaging != 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)
.Must(y => identityUser.RequestGroup == SpisumNames.Groups.MailroomGroup)
.WithName(x => "Group")
.WithMessage($"User is not member of {SpisumNames.Groups.MailroomGroup} group.");
});
RuleFor(x => x.DocumentType)
.Must(x => x == null || CodeLists.DocumentTypes.List.TryGetValue(x, out string _))
.WithMessage($"DocumentType must be one of [{string.Join(",", CodeLists.DocumentTypes.List.Select(x => x.Key).ToArray())}]");
}
public async Task WriteReportAsync(IIdentityUser user, string reportName)
{
try
{
if (_context == null)
{
return;
}
await _context.AuditCollection.InsertOneAsync(new AuditEntity
{
Action = $"{AuditOperation.ReportOpened}",
Date = DateTime.UtcNow,
ObjectId = -1,
ObjectTypeId = -1,
UserId = user.ItemId,
AdditionalParameters = new Dictionary <string, object>()
{
["ReportName"] = reportName
}
});
}
catch
{ }
}
public void CreateUser(IIdentityUser user)
{
var connection = Helper.Helper.GetConnectionString();
var context = new DataContext(connection);
context.UserDtos.Add((UserDTO)user);
context.SaveChanges();
}
public AccountService(SnsdbContext snsdbContext,
IWebHostEnvironment webHostEnvironment,
IIdentityUser <int, LoginAuthModel> identityUser)
{
_snsdbContext = snsdbContext;
_webHostEnvironment = webHostEnvironment;
_identityUser = identityUser;
}
public FileShreddingDiscardValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser 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.Properties}, {AlfrescoNames.Includes.Path}",
ParameterType.QueryString)));
_parentRM = await alfrescoHttpClient.GetNodeParents(context.NodeId, ImmutableList <Parameter> .Empty
.Add(new Parameter(AlfrescoNames.Headers.Include, AlfrescoNames.Includes.Properties, ParameterType.QueryString))
.Add(new Parameter(AlfrescoNames.Headers.Where, $"(assocType='{SpisumNames.Associations.FileInRepository}')", ParameterType.QueryString))
.Add(new Parameter(AlfrescoNames.Headers.MaxItems, "1", ParameterType.QueryString)));
if (_parentRM?.List?.Entries?.Count == 1)
{
var documentInfo = await alfrescoHttpClient.GetNodeInfo(_parentRM?.List?.Entries?.FirstOrDefault()?.Entry?.Id);
var rmdocumentProperties = documentInfo?.Entry?.Properties?.As <JObject>().ToDictionary();
_cutOffDate = rmdocumentProperties.GetNestedValueOrDefault(AlfrescoNames.ContentModel.CutOffDate)?.ToString();
}
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
return(_nodeEntry != null && _groupPaging != null && _parentRM != 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.File)
.WithMessage($"NodeId must be type of {SpisumNames.NodeTypes.File}.");
RuleFor(x => x.NodeId)
.Must(x => _parentRM?.List?.Entries.Count == 1)
.WithMessage(x => "File is not in record management");
RuleFor(x => x.NodeId)
.Must(x => !string.IsNullOrWhiteSpace(_cutOffDate))
.WithMessage(x => "Cut off date is not set yet");
});
RuleFor(x => x.Body.Date)
.Must(x => x.HasValue ? x.Value.Date >= DateTime.UtcNow.Date : true)
.When(w => w.Body != null)
.WithMessage("Date can't be in the past");
RuleFor(x => x.Body.Reason)
.MinimumLength(4)
.MaximumLength(30)
.When(x => x.Body != null);
}
public ArticleService(SnsdbContext snsdbContext, IIdentityUser <int, LoginAuthModel> identityUser,
IDistributedCache distributedCache,
IHttpContextAccessor httpContextAccessor)
{
_snsdbContext = snsdbContext;
_identityUser = identityUser;
_distributedCache = distributedCache;
_httpContextAccessor = httpContextAccessor;
}
public ComponentService(IAlfrescoHttpClient alfrescoHttpClient, INodesService nodesService, IPersonService personService,
IIdentityUser identityUser, IAuditLogService auditLogService)
{
_alfrescoHttpClient = alfrescoHttpClient;
_nodesService = nodesService;
_personService = personService;
_identityUser = identityUser;
_auditLogService = auditLogService;
}
public ValidationService(IAlfrescoHttpClient alfrescoHttpClient, ISignerService signerService, IPdfService pdfService, IComponentService componentService, ISignerClient signerClient, IIdentityUser identityUser, ISignerConfiguration signerConfiguration)
{
_signerService = signerService;
_pdfService = pdfService;
_componentService = componentService;
_signerClient = signerClient;
_identityUser = identityUser;
_alfrescoHttpClient = alfrescoHttpClient;
_signerConfiguration = signerConfiguration;
}
public User(IIdentityUser user)
{
ItemId = user.ItemId;
SmartCoreObjectType = SmartCoreType.User;
Name = user.Name;
Surname = user.Surname;
Login = user.Login;
Password = user.Password;
UserType = user.UserType;
UiType = user.UiType;
PersonnelId = user.PersonnelId;
}
public MedicalRepService(
IUnitWork unitWork,
IMedicalRepRepo repo,
IWebHostEnvironment environment,
IMapper mapper,
IIdentityUser identityUser) : base(environment)
{
_unitWork = unitWork;
_repo = repo;
_mapper = mapper;
_identityUser = identityUser;
}
public AuthenticationController(
IAlfrescoHttpClient alfrescoHttpClient,
IAuthorizationService authorizationService,
IIdentityUser identityUser,
ISimpleMemoryCache simpleMemoryCache
)
{
_alfrescoHttpClient = alfrescoHttpClient;
_authorizationService = authorizationService;
_identityUser = identityUser;
_simpleMemoryCache = simpleMemoryCache;
}
public FileCloseValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser 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},{AlfrescoNames.Includes.Properties}", ParameterType.QueryString)));
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
return(_groupPaging != null && _nodeEntry?.Entry?.Id != null);
})
.WithName("Document")
.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.File)
.WithMessage(x => $"Provided nodeId must be NodeType {SpisumNames.NodeTypes.File}");
});
RuleFor(x => x)
.Must(x =>
{
if (x?.Body?.SettleMethod != "jinyZpusob")
{
return(true);
}
if (x?.Body?.CustomSettleMethod == null || x?.Body?.SettleReason == null)
{
return(false);
}
if (x.Body.CustomSettleMethod.Length < 4 || x.Body.SettleReason.Length < 4)
{
throw new BadRequestException(ErrorCodes.V_MIN_TEXT);
}
x.Body.CustomSettleMethod = x.Body.CustomSettleMethod.CutLength(30);
x.Body.SettleReason = x.Body.SettleReason.CutLength(30);
return(true);
})
.WithName(x => nameof(x.Body.SettleMethod))
.WithMessage("You have to fill CustomSettleMethod and SettleReason.");
}
public static string ToJwtToken <TKey>(this IIdentityUser <TKey> user, string secret, string issuer, string audience, DateTime?expires)
{
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, user.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secret));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(issuer, audience, claims, expires: expires, signingCredentials: creds);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
public EmailDataBoxService(
IAlfrescoHttpClient alfrescoHttpClient,
IIdentityUser identityUser,
IComponentService componentService,
IMapper mapper,
INodesService nodesService
)
{
_alfrescoHttpClient = alfrescoHttpClient;
_identityUser = identityUser;
_componentService = componentService;
_mapper = mapper;
_nodesService = nodesService;
}
public AuditLogService(
IIdentityUser identityUser,
ITransactionHistoryRepository transactionHistoryRepository,
IAlfrescoModelComparer alfrescoModelComparer,
IMapper mapper,
ITranslateService translationService
)
{
_identityUser = identityUser;
_transactionHistoryRepository = transactionHistoryRepository;
_alfrescoModelComparer = alfrescoModelComparer;
_mapper = mapper;
_translateService = translationService;
}
public FileCancelValidator(IAlfrescoHttpClient alfrescoHttpClient, IIdentityUser 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)));
_secondaryChildren = await alfrescoHttpClient.GetNodeSecondaryChildren(context.NodeId, ImmutableList <Parameter> .Empty
.Add(new Parameter(AlfrescoNames.Headers.Where, $"(assocType='{SpisumNames.Associations.Documents}')", ParameterType.QueryString)));
_groupPaging = await alfrescoHttpClient.GetPersonGroups(identityUser.Id);
return(_nodeEntry?.Entry?.Id != null && _secondaryChildren != null && _groupPaging != 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.File)
.WithMessage(x => $"Provided nodeId must be NodeType {SpisumNames.NodeTypes.File}");
RuleFor(x => x)
.Must(x => _secondaryChildren?.List?.Entries?.Count == null || !_secondaryChildren.List.Entries.Any())
.OnAnyFailure(x => throw new BadRequestException(ErrorCodes.V_FILE_CANCEL_CHILDREN));
RuleFor(x => x)
.Must(x => _nodeEntry?.Entry?.Path?.Name?.StartsWith(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.Evidence, StringComparison.OrdinalIgnoreCase) == true)
.OnAnyFailure(x => throw new BadRequestException("Document must be in evidence site."));
RuleFor(x => x)
.Must(x => _nodeEntry?.Entry?.Path?.Name?.StartsWith(AlfrescoNames.Prefixes.Path + SpisumNames.Paths.EvidenceFilesOpen(identityUser.RequestGroup), StringComparison.OrdinalIgnoreCase) == true)
.OnAnyFailure(x => throw new BadRequestException("File can't be cancelled"));
RuleFor(x => x.NodeId)
.Must(x => IsNodePathAllowed(x, identityUser.RequestGroup));
});
RuleFor(x => x)
.Must(CheckReasonLength);
}
private async Task <IIdentityUser> GetUserInternalAsync()
{
if (user == null)
{
if (UserId != null)
{
user = await userStore.FindByIdAsync(UserId.Value);
if (user == null)
{
throw new InvalidOperationException($"GetUserAsync failed because the authenticated user with ID '{UserId.Value}' could not be found");
}
}
}
return(user);
}
public ConceptService(IAlfrescoHttpClient alfrescoHttpClient,
INodesService nodesService,
ITransactionHistoryService transactionHistoryService,
IIdentityUser identityUser,
IComponentService componentService,
IDocumentService documentService,
IAuditLogService auditLogService
)
{
_alfrescoHttpClient = alfrescoHttpClient;
_nodesService = nodesService;
_transactionHistoryService = transactionHistoryService;
_identityUser = identityUser;
_componentService = componentService;
_documentService = documentService;
_auditLogService = auditLogService;
}
