public virtual async Task <IApplicationResult> CreateAsync(TDto dto) { return(await ExecuteAsync(async() => { var isAdmin = await _roleService.IsAdminAsync(_inventAppContext.UserEmail); if (!isAdmin) { throw new UnauthorizedAccessException($"Access Denied. Check permissions for User '{_inventAppContext.UserEmail}'"); } await _duplicateValidator.ValidateAsync(dto); var aggregate = _factory.Create(dto); await _unitOfWork.GetRepository <TAggregateRoot>().AddAsync(aggregate); _auditService.AuditAsync(new Audit { Application = "InventApp", Environment = _appSettingsService.Environment.Name, User = _inventAppContext.UserEmail, EntityId = aggregate.Id.ToString(), EntityName = aggregate.GetType().Name, Entity = JsonConvert.SerializeObject(aggregate), Action = AuditAction.Create }); return new OkApplicationResult <Guid> { Data = aggregate.Id }; })); }
/// <inheritdoc/> public async Task QueueContractEmailReminderMessage(Contract contract) { _logger.LogInformation($"Queuing email reminder for contract [{contract.ContractNumber}]."); var message = new ContractReminderMessage() { ContractId = contract.Id }; IDictionary <string, string> properties = new Dictionary <string, string>() { { "messageType", ContractReminderMessage.MessageProcessor_ContractReminderMessage } }; await _sbMessagingService.SendAsBinaryXmlMessageAsync(message, properties); await _auditService.AuditAsync( new Pds.Audit.Api.Client.Models.Audit { Severity = 0, Action = Audit.Api.Client.Enumerations.ActionType.ContractEmailReminderQueued, Ukprn = contract.Ukprn, Message = $"Email reminder has been queued for contract with Id [{contract.Id}].", User = Audit_User_System }); }
public async Task <string> GetAsync(string requestQueryString, RequestType requestType) { using (var clientProxy = new HttpClient()) { clientProxy.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", _subscriptionKey); clientProxy.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));//ACCEPT header var requestRoute = requestType == RequestType.search ? $"{requestType.ToString()}?" : string.Empty; var fullRequest = $"{_endpoint}/{requestRoute}{requestQueryString}"; logger.Trace($"Getting API data for request :'{fullRequest}'"); var response = await clientProxy.GetAsync(fullRequest); var responseContent = await response.Content?.ReadAsStringAsync(); await auditService.AuditAsync(responseContent, requestQueryString); if (!response.IsSuccessStatusCode) { logger.Error($"Error status {response.StatusCode}, Getting API data for request :'{fullRequest}' \nResponse : {responseContent}", null); //this will throw an exception as is not a success code await response.EnsureSuccessStatusCodeAsync(); } return(responseContent); } }
public async Task DeleteOrphanedAvsAsync() { logger.Info("Getting orphaned apprenticeship vacancies"); var orphanedApprenticeshipVacancies = await apprenticeshipVacancyRepository.GetOrphanedApprenticeshipVacanciesAsync(); await auditService.AuditAsync($"Got {orphanedApprenticeshipVacancies.Count()} orphaned apprenticeship vacancies"); foreach (OrphanedVacancySummary o in orphanedApprenticeshipVacancies) { await auditService.AuditAsync($"Got orphaned apprenticeship deleting vacancies id= {o.Id} published = {o.PublicationDate.ToString()} title = {o.Title} vacancyId = {o.VacancyId}"); await apprenticeshipVacancyRepository.DeleteByIdAsync(o.Id); } logger.Info("Completed deleting orphaned apprenticeship vacancies"); }
/// <inheritdoc/> public async Task ProcessMessage(ContractApprovedMessage message) { if (message is null) { throw new ArgumentNullException(nameof(message)); } _logger.LogInformation($"Sending approved contract notification for {message.ContractNumber}."); await Post(_configuration.ApiContractApproverEndpoint, message); try { await _audit.AuditAsync(new Audit.Api.Client.Models.Audit() { Action = ActionType.ContractApprovedMessageSentToFCS, Severity = 0, User = ContractApproverUser, Ukprn = message.Ukprn, Message = $"Notified FCS of approved contract [{message.ContractNumber}] Version [{message.ContractVersionNumber}]." }); } catch (Exception e) { _logger.LogError(e, "Error when attempting to create an audit entry."); } }
private async Task <PagedOdataResult <T> > GetInternalAsync(Uri requestUri, bool shouldAudit) { using (var client = await GetHttpClientAsync()) { var resultMessage = await client.GetAsync(requestUri); if (resultMessage.StatusCode == System.Net.HttpStatusCode.Unauthorized) { throw new UnauthorizedAccessException(resultMessage.ReasonPhrase); } var result = await client.GetStringAsync(requestUri); logger.Info($"Requested with url - '{requestUri}'."); if (shouldAudit) { await auditService.AuditAsync($"{requestUri} | {result}"); } return(JsonConvert.DeserializeObject <PagedOdataResult <T> >(result)); } }
private async Task NotifyAsync <T>(T message, Contract contract, string component) { IDictionary <string, string> properties = new Dictionary <string, string>() { { "messageType", typeof(T).FullName } }; await _serviceBusMessagingService.SendAsBinaryXmlMessageAsync(message, properties); await _auditService.AuditAsync( new Pds.Audit.Api.Client.Models.Audit { Severity = 0, Action = Audit.Api.Client.Enumerations.ActionType.ContractNotificationForwarded, Ukprn = contract.Ukprn, User = Constants.Audit_User_System, Message = Constants.ContractNotificationForwardedMessage .ReplaceTokens(contract) .ReplaceTokens(new Dictionary <string, string> { { Constants.Component, component } }) }); }