public ValidatedResult <TResponse> Send <TResponse>(IRequest <TResponse> request)
{
using (LoggerContext.DecorateWithUser())
{
_logger.Debug("Send {@request} for {User}", request);
}
var validationSummary = _requestValidator.Validate(request);
return(GetValidatedResult(request, validationSummary));
}
public void Validate_InvalidLogFileId_ReturnsFailure(int logFileId)
{
RequestModel model = DataHelper.CreateRequestModel();
model.LogFileId = logFileId;
ValidationResult result = _requestValidator.Validate(model);
Assert.IsFalse(result.Success);
Assert.AreEqual(1, result.Messages.Count);
Assert.IsTrue(result.Messages[0].Contains("Log file id"));
}
/// <summary>Executes the command</summary>
/// <returns>The result of the command</returns>
public override BulkCopyResult Execute()
{
_requestValidator.Validate(CommandRequest);
if (CommandRequest.MappingType == MappingType.AutoMap || CommandRequest.MappingType == MappingType.PartialMap)
{
CommandRequest.ColumnMapping ??= new ColumnMapping();
_autoMapper.MapDataTableToTable(CommandRequest.DestinationTableName, CommandRequest.DataTable, CommandRequest.ColumnMapping);
}
return(_databaseCommander.BulkCopy(CommandRequest));
}
public async Task <IActionResult> GetUserTasks([FromBody] GetUserTasksRequest request)
{
var result = _requestValidator.Validate(request);
if (!result.IsValid)
{
throw new InvalidValueException(result.Errors.Select(e => e.ErrorMessage).Distinct().ToArray());
}
var tasks = await _tasksService.GetTasksByEmail(request.Email);
return(Ok(_mapper.Map <List <GetTaskResponse> >(tasks)));
}
public async Task GivenValidInput_ReturnsNoError()
{
var countries = new List <Country>()
{
new Country("TS", "Test")
};
_countryService.Setup(x => x.GetCountryByCountryCode("TS"))
.Returns(Task.FromResult(countries));
var validationError = await _requestValidator.Validate(100, "TS", "Swimming");
validationError.Count.ShouldBe(0);
}
public IActionResult Post(AddSampleRequest request)
{
var validationResult = requestValidator.Validate(request);
if (!validationResult.IsValid)
{
return(BadRequest(Messages.InvalidRequest));
}
var result = sampleService.Add(request);
return(!result.IsSuccess
? Problem(Messages.GeneralError)
: Ok(result.Message));
}
public bool ValidateCallback(HttpContext suppliedContext = null)
{
var contextToUse = _context ?? suppliedContext;
if (contextToUse == null)
{
throw new ArgumentNullException("request");
}
if (contextToUse.Request?.Host.Host == null)
{
return(false);
}
if (contextToUse.Request == null || contextToUse.Request.Form == null)
{
return(false);
}
string authorizationHeader = contextToUse.Request.Headers[_RevaleeAuthHttpHeaderName];
if (string.IsNullOrWhiteSpace(authorizationHeader))
{
return(false);
}
Guid callbackId;
if (!Guid.TryParse(contextToUse.Request.Form["callbackId"], out callbackId))
{
return(false);
}
var callbackUrl = $"{contextToUse.Request.Scheme}{UriKeys.SchemeDelimiter}{contextToUse.Request.Host.ToUriComponent()}{contextToUse.Request.Path.ToUriComponent()}";
return(_validator.Validate(authorizationHeader, callbackId, new Uri(callbackUrl)));
}
public async Task <CancelGameResult> Handle(CancelGame request, CancellationToken cancellationToken)
{
using (var transaction = repositoryTransactionsFactory.CreateTransaction())
{
var validatorResult = await validator.Validate(request);
if (!validatorResult.IsSuccessful)
{
return(new CancelGameResult(validatorResult.Error));
}
var ended = await gamesRepository.CancelGame(request.GameId);
if (!ended)
{
return(new CancelGameResult(GameErrors.GameCouldNotBeCancelled));
}
var checkpoint = await gameCheckpointUpdater.Update(request.GameId, nameof(SkipRound));
transaction.CommitTransaction();
return(new CancelGameResult());
}
}
public async Task <StartGameRoundResult> Handle(StartGameRound request, CancellationToken cancellationToken)
{
using (var transaction = repositoryTransactionsFactory.CreateTransaction())
{
var validatorResult = await validator.Validate(request);
if (!validatorResult.IsSuccessful)
{
return(new StartGameRoundResult(validatorResult.Error));
}
var started = await gameRoundsRepository
.UpdateGameRoundStatus(request.GameRoundId, Common.Enums.GameRoundStatusEnum.InProgress);
if (!started)
{
return(new StartGameRoundResult(GameErrors.GameRoundCouldNotBeStarted));
}
var checkpoint = await gameCheckpointUpdater.Update(request.GameId, nameof(StartGameRound));
transaction.CommitTransaction();
return(new StartGameRoundResult());
}
}
public async Task <EndSubmissionsResult> Handle(EndSubmissions request, CancellationToken cancellationToken)
{
using (var transaction = repositoryTransactionsFactory.CreateTransaction())
{
var validationResult = await requestValidator.Validate(request);
if (!validationResult.IsSuccessful)
{
return(new EndSubmissionsResult(validationResult.Error));
}
var updated = await gameRoundsRepository
.UpdateGameRoundStatus(request.GameRoundId, Common.Enums.GameRoundStatusEnum.Selection);
if (!updated)
{
return(new EndSubmissionsResult(GameErrors.CouldNotEndAnswersSubmissions));
}
var checkpoint = await gameCheckpointUpdater.Update(request.GameId, nameof(EndSubmissions));
transaction.CommitTransaction();
return(new EndSubmissionsResult());
}
}
public Audit <TableBooking> CreateBooking(BookingRequestDto bookingRequestDto)
{
var validationResult = _requestValidator.Validate(bookingRequestDto);
if (!validationResult.IsSucces)
{
throw new ValidationException(validationResult.Error);
}
var validatedRequest = validationResult.Ok;
var tables = _dataService.GetTables();
var bookingsForToday = _dataService.FindBookings(validatedRequest.Date);
var bookingCreationResult = _bookingCreator.Create(validatedRequest, tables, bookingsForToday);
if (!bookingCreationResult.IsSucces)
{
throw new NoSeatsException(bookingCreationResult.Error);
}
var createBy = CurrentContext.CurrentUser;
var createAt = DateTimeOffset.Now;
var auditedBooking = _dataService.SaveBooking(bookingCreationResult.Ok, createBy, createAt);
return(auditedBooking);
}
public async Task <JoinGameResult> Handle(JoinGame request, CancellationToken cancellationToken)
{
using (var transaction = repositoryTransactionsFactory.CreateTransaction())
{
var validationResult = await requestValidator.Validate(request);
if (!validationResult.IsSuccessful)
{
return(new JoinGameResult(validationResult.Error));
}
var maxNumber = await playersRepository.GetMaxPlayerNumberForGame(request.GameId);
var player = await CreatePlayer(request.GameId, request.UserId, ++maxNumber);
var cardCount = await CreatePlayerAnswerCards(request.GameId, player.PlayerId, GameConstants.StartingPlayerCardsCount);
if (cardCount != GameConstants.StartingPlayerCardsCount)
{
return(new JoinGameResult(GameErrors.NotEnoughAnswerCards));
}
await gameCheckpointUpdater.Update(request.GameId, nameof(JoinGame));
transaction.CommitTransaction();
return(new JoinGameResult
{
PlayerId = player.PlayerId
});
}
}
public async Task <CreateUserResult> Handle(AuthenticateGoogleUser request, CancellationToken cancellationToken)
{
var validationResult = await requestValidator.Validate(request);
if (!validationResult.IsSuccessful)
{
return(new CreateUserResult(validationResult.Error));
}
if (await usersRepository.GoogleUserExists(request.Email, request.GoogleId))
{
return(await UpdateExistingGoogleUser(request));
}
else
{
if (await usersRepository.UserEmailExists(request.Email))
{
return(await AddGoogleLoginToExistingUser(request));
}
else
{
return(await CreateNewGoogleUser(request));
}
}
}
public async Task <TokenResponse> Login(LoginRequest request)
{
var result = _requestValidator.Validate(request);
if (!result.IsValid)
{
throw new InvalidValueException(result.Errors.Select(e => e.ErrorMessage).Distinct().ToArray());
}
var token = await _identityProvider.RequestPasswordTokenAsync(request);
if (token.IsError)
{
throw new HttpStatusCodeException(HttpStatusCode.Forbidden, "Authentication failed");
}
return(JsonConvert.DeserializeObject <TokenResponse>(token.Raw));
}
public async Task <IActionResult> AddUser([FromBody] CreateUserRequest request)
{
var result = _requestValidator.Validate(request);
if (!result.IsValid)
{
{
throw new InvalidValueException(result.Errors.Select(e => e.ErrorMessage).Distinct().ToArray());
}
}
var user = _mapper.Map <User>(request);
await _usersService.AddUser(user);
return(Ok(new CreateUserResponse()
{
UserId = user.UserId
}));
}
public Task <ServiceResponse> OnRequest <TReq>(IServiceInstance service, TReq request, CancellationToken cancellationToken) where TReq : BaseRequest, new()
{
IDictionary <string, string[]> validationResult = _requestValidator.Validate(request);
if (validationResult.Count == 0)
{
return(Task.FromResult(this.ContinuePipeline()));
}
return(Task.FromResult(new ServiceResponse(new ResponseMetaData(service, ServiceResult.ValidationError, validationErrors: validationResult))));
}
public async Task <IHttpActionResult> GetGiftAid(decimal donationAmount, string country, string eventType)
{
var validationErrors = await _requestValidator.Validate(donationAmount, country, eventType);
if (validationErrors.Any())
{
return(Content(HttpStatusCode.BadRequest, new GiftAidErrorResponse(validationErrors)));
}
var giftAidAmount = await _giftAidOrchestrationService.CalculateGiftAid(donationAmount, country, eventType);
return(Content(HttpStatusCode.OK, new GiftAidResponse(giftAidAmount)));
}
public async Task <IActionResult> Estimate([FromQuery] TaxiRequest order)
{
if (_validator.Validate(order) == false)
{
return(BadRequest());
}
var price = await _taxi.EstimateOrderAsync(order);
var vm = _mapper.Map(price);
return(Ok(vm));
}
public ActionResult ValidateData([FromBody] ValidationRequest request)
{
var requestValidation = _validator.Validate(request);
if (!requestValidation.IsValid)
{
return(BadRequest(requestValidation.InvalidReason));
}
var job = _jobFactory.Create(request);
string jobId = BackgroundJob.Enqueue(() => job.Execute(request));
return(Ok(jobId));
}
public override async Task get_calendar_information(CalendarInformationRequest request, IServerStreamWriter <CalendarInformationReply> responseStream,
ServerCallContext context)
{
_logger.LogInformation($"GetCalendarInformation request for {request.Calendar.CalendarId}");
_requestValidator.Validate(request);
var graphCalendarClient = CreateGraphCalendarClient(request.Client);
var graphEvents = await graphCalendarClient.GetEventsAsync(request.Calendar);
var azureReplyEvents = CreateReplyEventsOf(graphEvents);
_logger.LogInformation($"Sending response for request {request}");
foreach (var replyEvent in azureReplyEvents)
{
if (context.CancellationToken.IsCancellationRequested)
{
break;
}
await responseStream.WriteAsync(replyEvent);
}
}
public async Task <ActionResult> CreateWorkDefinition(WorkDefinitionEvent workdefinition)
{
workdefinition = await base.ReadRequestContentAsync(workdefinition);
workdefinition.ReceivedUTC = DateTime.UtcNow;
#region Workaround to fix CustomJsonConverter save default value as -999999
var serializedWorkDefinition = JsonHelper.SerializeObjectToJson(workdefinition, new JsonSerializerSettings {
ContractResolver = new ShouldSerializeContractResolver()
});
workdefinition = JsonConvert.DeserializeObject <WorkDefinitionEvent>(serializedWorkDefinition);
#endregion
var result = await _requestValidator.Validate(new AssetSettingValidationRequestBase
{
AssetUIDs = new List <string> {
workdefinition.AssetUID.ToString()
},
DeviceType = workdefinition.DeviceType,
GroupName = "WorkDefinitions"
});
if (result.Any(x => x.IsInvalid))
{
_loggingService.Warn(result.First().Message + " for AssetUID : " + workdefinition.AssetUID.ToString(), "WorkDefinitionV1Controller.CreateWorkDefinition");
return(BadRequest(result.First().Message));
}
if (_wdRepo.WorkDefinitionExist(workdefinition.AssetUID))
{
return(BadRequest("Work Definition already exist for given asset."));
}
_wdRepo.CreateWorkDefinition(workdefinition);
return(StatusCode((int)HttpStatusCode.OK));
}
public Resp ProcessRequest(Req request)
{
Resp result = null;
// Validate BaseRequest
IInputValidationResult baseValidationResult = _baseValidator.Validate(request);
// If BaseRequest is valid - then validate specific request
if (baseValidationResult.ValidationResult == ValidationResultType.Success)
{
IRequestValidator <Req> validator = GetInputRequestValidator(request);
InpValRes validationResult = (InpValRes)validator.Validate(request);
switch (validationResult.ValidationResult)
{
case ValidationResultType.Success:
result = HandleValidRequest(request, validationResult);
break;
case ValidationResultType.Warning:
result = HandleWarningRequest(request, validationResult);
break;
case ValidationResultType.Error:
result = HandleInvalidRequest(request, validationResult);
break;
default:
throw new ArgumentOutOfRangeException("Unknown ValidationResult");
}
}
else
{
// Should we handle it here in the base manager or send it back to the implementing class as HandleInvalidRequest ?
// I think we should handle it here
// TODO - Decorate response from BaseRequestValidator with enough information to set these properties below with valid
// information across all interfaces
result = HandleInvalidBaseRequest(baseValidationResult);
}
// TODO Log outgoing request - perhaps?
return(result);
}
public async Task <CreateGameResult> Handle(CreateGame request, CancellationToken cancellationToken)
{
using (var transaction = repositoryTransactionsFactory.CreateTransaction())
{
var validationResult = await requestValidator.Validate(request);
if (!validationResult.IsSuccessful)
{
return(new CreateGameResult(validationResult.Error));
}
var gameCode = codeGenerator.Generate();
var game = await CreateGame(request, gameCode);
var player = await CreatePlayer(game.GameId, request.UserId);
var createRoundResult = await gameRoundCreator
.CreateFirstRound(game.GameId, player.PlayerId);
if (!createRoundResult.IsSuccessful)
{
return(new CreateGameResult(createRoundResult.Error));
}
var createCardsResult = await playerCardsCreator.CreateCardsForPlayer(game.GameId, player.PlayerId);
if (!createCardsResult.IsSuccessful)
{
return(new CreateGameResult(createCardsResult.Error));
}
var checkpoint = await gameCheckpointUpdater.Update(game.GameId, nameof(CreateGame));
transaction.CommitTransaction();
return(new CreateGameResult
{
GameId = game.GameId,
PlayerId = player.PlayerId,
Code = gameCode,
Checkpoint = checkpoint
});
}
}
public async Task <SkipRoundResult> Handle(SkipRound request, CancellationToken cancellationToken)
{
using (var transaction = repositoryTransactionsFactory.CreateTransaction())
{
var validatorResult = await validator.Validate(request);
if (!validatorResult.IsSuccessful)
{
return(new SkipRoundResult(validatorResult.Error));
}
var skipped = await gameRoundsRepository
.SkipRound(request.GameRoundId);
if (!skipped)
{
return(new SkipRoundResult(GameErrors.GameRoundCouldNotBeSkipped));
}
var createNewRoundResult = await gameRoundCreator
.CreateRound(request.GameId, request.GameRoundId);
if (!createNewRoundResult.IsSuccessful)
{
return(new SkipRoundResult(createNewRoundResult.Error));
}
var createCardsResult = await playerCardsCreator
.CreateCards(request.GameId);
if (!createCardsResult.IsSuccessful)
{
return(new SkipRoundResult(createCardsResult.Error));
}
var checkpoint = await gameCheckpointUpdater.Update(request.GameId, nameof(SkipRound));
transaction.CommitTransaction();
return(new SkipRoundResult());
}
}
public async Task<SubmitAnswerResult> Handle(SubmitAnswer request, CancellationToken cancellationToken)
{
using (var transaction = repositoryTransactionsFactory.CreateTransaction())
{
var validatorResult = await requestValidator.Validate(request);
if (!validatorResult.IsSuccessful)
return new SubmitAnswerResult(validatorResult.Error);
var player = await playersRepository.GetPlayerByUserId(request.UserId, request.GameId);
int playerAnswerId = await SubmitAnswer(request, player);
if (playerAnswerId == 0)
return new SubmitAnswerResult(GameErrors.SubmitAnswerFailed);
await gameCheckpointUpdater.Update(request.GameId, nameof(Model.Core.Games.SubmitAnswer));
transaction.CommitTransaction();
return new SubmitAnswerResult();
}
}
public async Task <ValidatorResult> Validate(IBaseRequest request)
{
if (request is IGameRequest)
{
var result = await gameRequestValidator.Validate(request as IGameRequest);
if (!result.IsSuccessful)
{
return(new ValidatorResult(result.Error));
}
}
if (request is IGameRoundRequest)
{
var result = await gameRoundRequestValidator.Validate(request as IGameRoundRequest);
if (!result.IsSuccessful)
{
return(new ValidatorResult(result.Error));
}
}
if (request is IUserRequest)
{
var result = await userRequestValidator.Validate(request as IUserRequest);
if (!result.IsSuccessful)
{
return(new ValidatorResult(result.Error));
}
}
if (request is IPlayerRequest)
{
var result = await playerRequestValidator.Validate(request as IPlayerRequest);
if (!result.IsSuccessful)
{
return(new ValidatorResult(result.Error));
}
}
return(new ValidatorResult());
}
public async Task <IActionResult> Report([FromBody] SightingRequest request,
CancellationToken cancellationToken)
{
try
{
var validate = _requestValidator.Validate(request);
if (validate.Succeeded)
{
await _service.ReportSighting(request, cancellationToken);
return(Ok());
}
return(BadRequest(new { rejectionReason = validate.Reason }));
}
catch (Exception ex)
{
_logger.Error($"Error occured while reporting a sighting. ${ex.Message}", ex);
throw;
}
}
public Task <ServiceResponse> OnRequest <TReq>(IServiceInstance service, TReq request, CancellationToken cancellationToken) where TReq : BaseRequest, new()
{
var stateMachineRequest = request as BaseStatefulRequest <TTrigger>;
if (stateMachineRequest?.Trigger == null)
{
return(Task.FromResult(this.ContinuePipeline()));
}
var props = stateMachineRequest.GetType().GetProperties();
var match = props.FirstOrDefault(x => x.Name.Equals(stateMachineRequest.Trigger.Value.ToString(), StringComparison.InvariantCultureIgnoreCase));
if (match == null)
{
return(Task.FromResult(this.ContinuePipeline()));
}
var matchValue = match.GetValue(stateMachineRequest);
if (matchValue == null)
{
return
(Task.FromResult(
new ServiceResponse(new ResponseMetaData(
service,
ServiceResult.ValidationError,
validationErrors: ValidationHelper.Create("Is a required property", match.Name)))
));
}
var validationResult = _requestValidator.Validate(match.GetValue(stateMachineRequest), match.Name);
if (validationResult.Count == 0)
{
return(Task.FromResult(this.ContinuePipeline()));
}
return(Task.FromResult(new ServiceResponse(new ResponseMetaData(service, ServiceResult.ValidationError, validationErrors: validationResult))));
}
public void Execute_ValidationSucceeds_BatchInserted()
{
int logFileId = new Random().Next(1, 1000);
_requestValidator.Validate(Arg.Any <RequestModel>()).Returns(new ValidationResult());
using (StreamReader logStream = new StreamReader(TestAsset.ReadTextStream(TestAsset.LogFile)))
{
var logEvents = W3CEnumerable.FromStream(logStream).ToList();
int eventCount = logEvents.Count;
Assert.Greater(eventCount, 1);
// execute
_createRequestBatchCommand.Execute(logFileId, logEvents);
// assert
_requestValidator.Received(eventCount).Validate(Arg.Any <RequestModel>());
// should receive eventCount + 1 -> delete also done
_dbContext.Received(eventCount + 1).ExecuteNonQuery(Arg.Any <string>(), Arg.Any <object>());
}
}
public async Task <CreateUserResult> Handle(CreateUser request, CancellationToken cancellationToken)
{
var validationResult = await requestValidator.Validate(request);
if (!validationResult.IsSuccessful)
{
return(new CreateUserResult(validationResult.Error));
}
var userCode = codeGenerator.Generate();
var imageUrl = imageUrlProvider.GetImageUrl(request.Email);
var result = await usersRepository.CreateUser(new CreateUserModel
{
Email = request.Email,
DisplayName = request.DisplayName,
Password = request.Password,
Code = userCode,
ImageUrl = imageUrl,
});
if (!result.IsSuccessful)
{
return(new CreateUserResult(result.Error));
}
return(new CreateUserResult
{
User = new UserModel
{
UserId = result.Model.UserId,
Email = result.Model.Email,
DisplayName = result.Model.DisplayName,
UserName = result.Model.UserName,
Code = result.Model.Code,
ImageUrl = result.Model.ImageUrl
}
});
}
