public Response <ValidationResponse> Post([FromBody] ValidationRequest request)
{
var result = new Response <ValidationResponse>("payment/validate", 2);
result.Data = new ValidationResponse();
try
{
var detector = new CreditCardDetector(request.CreditCardNumber);
result.Data.Status = detector.IsValid(CardIssuer.MasterCard, CardIssuer.Maestro, CardIssuer.Visa, CardIssuer.AmericanExpress, CardIssuer.DinersClub, CardIssuer.Discover, CardIssuer.RuPay);
if (!result.Data.Status)
{
result.Data.Message = "credit card is not valid. currently supporting only mastercard, maestro, visa, americanexpress, dinersclub, discover and rupay cards";
}
}
catch (Exception e)
{
result.Data.Status = false;
result.Data.Message = e.Message;
}
return(result);
}
/// <summary>
/// Processes Alexa request AND validates request signature
/// </summary>
/// <param name="httpRequest"></param>
/// <returns></returns>
public virtual HttpResponseMessage GetResponse(HttpRequestMessage httpRequest)
{
var request = new ValidationRequest { HttpRequest = httpRequest, RequestTime = DateTime.UtcNow };
var response = OnRequestValidation(request);
if (!response.Success) {
return new HttpResponseMessage(HttpStatusCode.BadRequest) {
ReasonPhrase = response.ValidationResult.ToString()
};
}
string alexaResponse = DoProcessRequest(response.AlexaRequest);
HttpResponseMessage httpResponse;
if (alexaResponse == null) {
httpResponse = new HttpResponseMessage(HttpStatusCode.InternalServerError);
}
else {
httpResponse = new HttpResponseMessage(HttpStatusCode.OK);
httpResponse.Content = new StringContent(alexaResponse, Encoding.UTF8, "application/json");
Debug.WriteLine(httpResponse.ToLogString());
}
return httpResponse;
}
public void Handler_Shall_Pass_Validattion_to_next()
{
var validations = new Dictionary <ValidationTypes, IValidation>()
{
{
ValidationTypes.Security,
new SecurityValidation(
ValidationResult.Valid,
new DateTime(2019, 10, 1))
},
{
ValidationTypes.Comfort,
new ComfortValidation(
ValidationResult.Valid,
new DateTime(2019, 10, 1))
}
};
IValidationRequest request
= new ValidationRequest(validations);
IHandler comfortHandler
= new ValidationHandler <IValidationRequest, ComfortValidation>(
request,
new ComfortValidation(ValidationResult.OnReview, new DateTime(2019, 10, 1)),
null);
IHandler securityHandler
= new ValidationHandler <IValidationRequest, SecurityValidation>(
request,
new SecurityValidation(ValidationResult.Valid, new DateTime(2019, 10, 1)),
comfortHandler);
securityHandler.Handle();
}
private void ValidationRequestHandler(ValidationRequest request)
{
ValidationResponse response = new ValidationResponse(request);
EventArguments.ClientValidatingEventArgs args = new EventArguments.ClientValidatingEventArgs(() =>
{
//Confirm Action
Status = StatusEnum.Validated;
Email = request.Email;
response.IsValid = true;
SendMessage(response);
Server.OnClientValidated(this);
},
() =>
{
//Refuse Action
response.IsValid = false;
response.HasError = true;
response.Exception = new AuthenticationException("Login failed for user " + request.Email);
SendMessage(response);
});
args.Receiver = this;
args.Request = request;
Server.OnClientValidating(args);
}
public ValidationResponse Validate(ValidationRequest sessionValidationRequest, bool save)
{
var validationResponse = new ValidationResponse
{
ServerValidatedSessionID = 11,
Errors = new List <string>(),
Warnings = new List <string> {
"This is a warning"
},
Messages = new List <string> {
"This is a message"
},
NoteQuestions = new List <NoteQuestion>
{
new NoteQuestion {
NoteQuestionID = 2, Question = "Programs Reviewed"
},
new NoteQuestion {
NoteQuestionID = 3, Question = "Behaviors Reviewed"
}
},
};
if (sessionValidationRequest.RequestedValidatedSession.Duration > TimeSpan.FromMinutes(30))
{
validationResponse.Errors.Add("The time cannot be more than 30 minutes");
}
return(validationResponse);
}
public ValidationResult Validate(IBehaviorContext context, ValidationRequest request)
{
Log.Append(ViewModelValidationSourceBehaviorTests.Validate);
LastContext = context;
LastRequest = request;
return(ResultToReturn);
}
public async Task ForwardsCallToValidatorStateService()
{
var request = new ValidationRequest(Guid.NewGuid(), 42, "somepackage", "somversion", "https://example.com/package.nupkg");
var status = new ValidatorStatus
{
State = ValidationStatus.Incomplete,
NupkgUrl = null,
ValidatorIssues = new List <ValidatorIssue>()
};
_validatorStateServiceMock
.Setup(vss => vss.GetStatusAsync(request))
.ReturnsAsync(status);
var result = await _target.GetResultAsync(request);
_validatorStateServiceMock
.Verify(vss => vss.GetStatusAsync(request), Times.Once);
_validatorStateServiceMock
.Verify(vss => vss.GetStatusAsync(It.IsAny <ValidationRequest>()), Times.Once);
_validatorStateServiceMock
.Verify(vss => vss.GetStatusAsync(It.IsAny <Guid>()), Times.Never);
Assert.Empty(result.Issues);
Assert.Equal(status.State, result.Status);
Assert.Equal(status.NupkgUrl, result.NupkgUrl);
}
private void PrizeLevelListChanged(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName.Equals("PrizeLevelList"))
{
PrizeLevelList.Children.Clear();
for (int i = 0; i < _model.NumberOfPrizeLevels; ++i)
{
var prizeLevelUC = new PrizeLevelUserControl(_model.PrizeLevelList[i]);
prizeLevelUC.SetLocalization(_localization.PrizeLevel);
prizeLevelUC.GotFocus += FocusPrizeLevel;
prizeLevelUC.LostFocus += LostFocusPrizeLevel;
prizeLevelUC.CloseButton.IsEnabled = true;
if (ValidationRequest != null)
{
foreach (var validator in ValidationRequest.GetInvocationList())
{
prizeLevelUC.SetValidator(validator as ValidationRequested);
}
}
PrizeLevelList.Children.Add(prizeLevelUC);
}
if (ValidationRequest != null)
{
ValidationRequest();
}
if (PrizeLevelList.Children.Count == 2)
{
foreach (UIElement currentPL in PrizeLevelList.Children)
{
(currentPL as PrizeLevelUserControl).CloseButton.IsEnabled = false;
}
}
}
}
public void OnMessageReceived(BrokeredMessage receivedMessage)
{
try
{
Trace.WriteLine("Processing Service Bus message: " + receivedMessage.SequenceNumber.ToString());
ValidationRequest request = receivedMessage.GetBody <ValidationRequest>();
Image image = db.Images.Find(request.imageId);
if (ImageStorage.Validate(request.imageId))
{
image.Validated = true;
db.SaveChanges();
}
else
{
ImageStorage.DeleteFile(null, request.imageId);
db.Images.Remove(image);
db.SaveChanges();
}
receivedMessage.Complete();
}
catch
{
// Handle any Message
}
}
private async Task PreProcessFile(SingleFile file)
{
var request = new ValidationRequest()
{
FileName = file.FileName, Flow = file.Flow
};
var validateresponse = await _service.Validate(request);
file.Valid = validateresponse.Valid;
if (validateresponse.Messages != null)
{
file.Messages.AddRange(validateresponse.Messages);
}
if (file.Valid && file.IsArchive)
{
var templocation = Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(file.FileName));
Directory.CreateDirectory(templocation);
using (ZipArchive archive = ZipFile.OpenRead(file.FileName))
{
foreach (ZipArchiveEntry entry in archive.Entries)
{
string extractedfile = Path.Combine(templocation, entry.FullName);
entry.ExtractToFile(extractedfile);
file.SingleFiles.Add(new SingleFile(Guid.NewGuid())
{
Flow = file.Flow, FileName = extractedfile, ParentId = file.DeliveryId, SubFolder = Path.GetFileNameWithoutExtension(file.FileName)
});
}
}
}
foreach (var sf in file.SingleFiles)
{
await PreProcessFile(sf);
}
}
public static void AreEqual(ValidationRequest expected, ValidationRequest actual)
{
if (!AreEqualCore(expected, actual))
{
Assert.Fail("Expected {0} but was {1}.", expected, actual);
}
}
public async Task WhenRepositorySigningIsDisabled_SuppressesNupkgUrl()
{
_config.RepositorySigningEnabled = false;
var request = new ValidationRequest(Guid.NewGuid(), 42, "somepackage", "somversion", "https://example.com/package.nupkg");
var status = new ValidatorStatus
{
State = ValidationStatus.Incomplete,
NupkgUrl = "https://nuget.test/package.nupkg",
ValidatorIssues = new List <ValidatorIssue>()
};
_validatorStateServiceMock
.Setup(vss => vss.GetStatusAsync(request))
.ReturnsAsync(status);
var result = await _target.GetResultAsync(request);
_validatorStateServiceMock
.Verify(vss => vss.GetStatusAsync(request), Times.Once);
_validatorStateServiceMock
.Verify(vss => vss.GetStatusAsync(It.IsAny <ValidationRequest>()), Times.Once);
_validatorStateServiceMock
.Verify(vss => vss.GetStatusAsync(It.IsAny <Guid>()), Times.Never);
Assert.Empty(result.Issues);
Assert.Equal(status.State, result.Status);
Assert.Null(result.NupkgUrl);
}
public async Task DoesNotSkipCheckWhenPackageFitsCriteria()
{
var request = new ValidationRequest(Guid.NewGuid(), 42, "somepackage", "somversion", "https://example.com/package.nupkg");
var status = new ValidatorStatus
{
State = ValidationStatus.NotStarted,
NupkgUrl = null,
ValidatorIssues = new List <ValidatorIssue>()
};
_criteriaEvaluatorMock
.Setup(ce => ce.IsMatch(It.IsAny <ICriteria>(), It.IsAny <SymbolPackage>()))
.Returns(false);
_validatorStateServiceMock
.Setup(vss => vss.GetStatusAsync(request))
.ReturnsAsync(status);
var result = await _target.GetResultAsync(request);
Assert.Equal(ValidationStatus.NotStarted, result.Status);
_validatorStateServiceMock
.Verify(vss => vss.GetStatusAsync(It.IsAny <ValidationRequest>()), Times.Once);
_validatorStateServiceMock
.Verify(vss => vss.GetStatusAsync(It.IsAny <Guid>()), Times.Never);
}
/// <summary>
/// Add a new prize level
/// </summary>
/// <param name="model">The prize level model</param>
/// <returns></returns>
public bool AddPrizeLevel(PrizeLevelModel model)
{
if ((_prizeLevelList ?? (_prizeLevelList = new List <PrizeLevelModel>())).Count < MaxPrizeLevels)
{
model.Index = _prizeLevelList.Count;
if (ValidationRequest != null)
{
foreach (var i in ValidationRequest.GetInvocationList())
{
model.SetValidator(i as ValidationRequested);
}
}
_prizeLevelList.Add(model);
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs("NumberOfPrizeLevels"));
PropertyChanged(this, new PropertyChangedEventArgs("PrizeLevelList"));
PropertyChanged(this, new PropertyChangedEventArgs("PrizeLevelList2"));
}
return(true);
}
else
{
return(false);
}
}
private ValidationResponse ValidateSavedFile(
string originalFileName,
string savedFilePath)
{
ValidationResponse validationResponse = null;
// Send request to Validation service
ValidationRequest validationRequest = new ValidationRequest
{
PostedFileName = originalFileName,
SavedFileName = Path.GetFileName(savedFilePath)
};
try
{
validationResponse = _validationService.Validate(validationRequest);
}
finally
{
if (_fileSystem.FileExists(savedFilePath))
{
_fileSystem.FileDelete(savedFilePath);
}
}
return(validationResponse);
}
/// <summary>
/// Adds a division to the model
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool AddDivision(DivisionModel model)
{
if ((_divisionList ?? (_divisionList = new List <DivisionModel>())).Count < MaxDivisions)
{
if (ValidationRequest != null)
{
foreach (var i in ValidationRequest.GetInvocationList())
{
model.SetValidator(i as ValidationRequested);
}
}
_divisionList.Add(model);
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs("DivisionList"));
PropertyChanged(this, new PropertyChangedEventArgs("NumberOfDivisions"));
}
if (ValidationRequest != null)
{
ValidationRequest();
}
return(true);
}
else
{
return(false);
}
}
public Response <ValidationResponse> Post([FromBody] ValidationRequest request)
{
var result = new Response <ValidationResponse>("payment/validate", 1);
result.Data = new ValidationResponse();
try
{
var detector = new CreditCardDetector(request.CreditCardNumber);
result.Data.Status = detector.IsValid(CardIssuer.MasterCard, CardIssuer.Visa);
if (!result.Data.Status)
{
result.Data.Message = "credit card is not valid. currently supporting only mastercard and visa cards";
}
}
catch (Exception e)
{
result.Data.Status = false;
result.Data.Message = e.Message;
}
return(result);
}
private async Task <ValidationResponse> ValidateSavedFileAsync(
HttpRequestBase request,
string baseAddress,
string originalFileName,
string savedFilePath)
{
ValidationResponse validationResponse = null;
request.ContentType = "application/json";
// Send request to Validation service
ValidationRequest validationRequest = new ValidationRequest
{
PostedFileName = originalFileName,
SavedFileName = Path.GetFileName(savedFilePath)
};
try
{
validationResponse = await GetValidationResponse(validationRequest, baseAddress);
}
finally
{
if (_fileSystem.FileExists(savedFilePath))
{
_fileSystem.DeleteFile(savedFilePath);
}
}
return(validationResponse);
}
public async Task <ValidationResponse> Validate(ValidationRequest request)
{
ValidationResponse response = new ValidationResponse();
foreach (var valrule in context.FlowValidations.Where(r => r.FlowConfiguration.Flow == request.Flow && r.Extension == Path.GetExtension(request.FileName).ToLower()))
{
Match m = Regex.Match(Path.GetFileName(request.FileName), valrule.Filter, RegexOptions.IgnoreCase);
if (m.Success)
{
request.Rule = new ValidationRule()
{
Content = valrule.Content, Extensie = valrule.Extension, Filter = valrule.Filter
};
break;
}
}
if (request.Rule == null)
{
response.Valid = false;
response.Messages = new string[] { "no rule found" };
}
else
{
IValidator validator = ValidatorFactory.CreateValidator(request);
response = await validator.Validate();
}
return(response);
}
public async Task SendsMessage()
{
var request = new ValidationRequest(Guid.NewGuid(), 42, "somepackage", "someversion", "https://example.com/testpackage.nupkg");
await _target.EnqueueScanAsync(request.ValidationId, request.NupkgUrl);
Assert.Same(_serializedMessage, _capturedBrokeredMessage);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] ValidationRequest request,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
log.LogInformation($"request: {JsonConvert.SerializeObject(request)}");
IActionResult response;
var extensionAttribute = GetExtensionAttribute(request.SignInName);
if (extensionAttribute == null)
{
response = GenerateErrorMessageWithMessage("Extension attribute is not valid!");
}
else
{
// Return the output claim(s)
response = new OkObjectResult(new ValidationResponseContent
{
SignInName = request.SignInName,
ExtensionAttribute = extensionAttribute
});
}
log.LogInformation($"response: {JsonConvert.SerializeObject(response)}");
return(response);
}
public bool CompareHashSettingsLicenseAndRequest(License license, ValidationRequest validationRequest)
{
return(string.Equals(
Crypto.concatenate_sha256_hash(license.LicenseSettings.GetValueList()),
Crypto.concatenate_sha256_hash(validationRequest.ValidationSettings.GetValueList())
));
}
public SessionReportConfiguration GetSessionReportConfiguration(ValidationRequest sessionValidationRequest)
{
// TODO: Change this call to the real call to return the SessionReportConfiguration for the ValidationRequest services
var aabcSessionReportConfiguration = AABC.DomainServices.Sessions.SessionReportConfiguration.CreateSample();
// convert the aabcSessionReportConfiguration to an ATrack SessionReportConfiguration
return(ConvertSessionReportConfiguration(aabcSessionReportConfiguration));
}
public async Task <ValidationResponse> Validate(ValidationRequest request)
{
if (!(request is DigitalSupportsValidationRequest r))
{
throw new InvalidOperationException($"{nameof(ISupportProcessingStrategy)} of type {nameof(DigitalSupportProcessingStrategy)} can only handle {nameof(DigitalSupportsValidationRequest)} request types");
}
return(await HandleInternal(r));
}
public ValidationResponse Validate(ValidateUserSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
var mock = bool.Parse(ConfigurationManager.AppSettings.Get("Mock"));
if (!mock)
{
try
{
var identification = new Identification
{
Number = settings.Identification,
Type = settings.IdentificationType
};
var dataValidation = new ValidationRequest
{
Identification = identification,
LastName = settings.LastName,
Names = settings.Names,
SecondLastName = settings.SecondLastName,
ExpeditionDate = new ExpeditionDate
{
Timestamp = settings.ExpeditionDate.ToTimestamp()
}
};
var serialized = _xmlProcessor.Serialize(dataValidation);
var response = validar(settings.ParamProduct, settings.Product, settings.Channel, serialized);
var deserialized = _xmlProcessor.Deserialize <ValidationResponse>(response);
return(deserialized);
}
catch (Exception exception)
{
var clientLog = new TelemetryClient();
clientLog.TrackException(exception);
clientLog.TrackException(exception);
var consultationException =
_webSettingsConsultationSettingsBuilder.WithPayload(
JsonConvert.SerializeObject(new { Exception = exception }))
.WithExecutionId(settings.ExecutionId)
.WithTypeOfConsultation((int)TypeOfConsultation.CommunicationError)
.WithWebServiceName("Error consultando " + ServiceNameType.Validate.GetStringValue())
.Build();
AddWebServiceConsultation(consultationException);
return(new ValidationResponse
{
ProcessResult = false
});
}
}
return(new ValidationResponse
{
Result = 5,
ProcessResult = true,
});
}
public ActionResult ValidateScholarship(ValidationRequest requestModel, HttpPostedFileBase[] scholarshipForms, string parentFirstName, string parentMiddleName, string parentLastName)
{
try
{
if (User.IsInRole("Student"))
{
string firstNameParent = parentFirstName;
string middleNameParent = parentMiddleName;
string lastNameParent = parentLastName;
ModelState.Remove("parentFirstName");
ModelState.Remove("parentMiddleName");
ModelState.Remove("parentLastName");
if (ModelState.IsValid)
{
if (FileVerification.AreFilesPDF(scholarshipForms))
{
studentActions.UploadStudentRequest(requestModel);
AddRequestFilesToResource(requestModel, scholarshipForms);
if (firstNameParent != null && middleNameParent != null && lastNameParent != null)
{
studentActions.InsertParent(requestModel.RequestID, firstNameParent, middleNameParent, lastNameParent);
}
return(RedirectToAction("RequestStatus"));
}
else
{
ViewBag.errorMessage = "Please upload pdf files only. Please try again.";
}
}
else
{
ViewBag.errorMessage = "Invalid inputs. Please try again.";
}
bool isScholarshipSiblingDiscount = studentActions.GetScholarshipByID(requestModel.ScholarshipID).ScholarshipName.ToLower() == "sibling discount" ? true : false;
ViewBag.isScholarshipSiblingDiscount = isScholarshipSiblingDiscount;
bool isStudentPassedApplicationForm = studentActions.IsStudentPassedApplicationForm(requestModel.ScholarshipID, User.Identity.GetUserId());
ViewBag.isStudentPassedApplicationForm = isStudentPassedApplicationForm;
return(View(requestModel)); //fall-through
}
else
{
TempData["errorMessage"] = "Sorry you do not have access.";
return(RedirectToAction("Announcement", "WebsiteContent"));
}
}
catch (Exception e)
{
TempData["errorMessage"] = "There was an error. Please try again, thank you!" + e.ToString();
return(RedirectToAction("RequestStatus"));
}
}
public JwtResponse Validate(ValidationRequest validationRequest)
{
var identity = _authService.ValidatePin(validationRequest.Token, validationRequest.Pin);
var jwt = BuildToken(identity);
return(new JwtResponse {
Token = jwt
});
}
public ActionResult Upload(ImageView image,
HttpPostedFileBase ImageFile)
{
CheckAda();
ApplicationUser user = GetLoggedInUser();
ViewData["tags"] = new SelectList(db.Tags, "Id", "Name", 1);
if (ModelState.IsValid)
{
/*
* Save image infomation in the database
*/
Image imageEntity = new Image();
imageEntity.Caption = image.Caption;
imageEntity.Description = image.Description;
imageEntity.DateTaken = image.DateTaken;
imageEntity.TagId = image.TagId;
imageEntity.UserId = user.Id;
imageEntity.Validated = false;
imageEntity.Approved = false;
if (ImageFile != null && ImageFile.ContentLength > 0)
{
if (!ImageFile.ContentType.Equals("image/jpeg"))
{
ViewBag.Message = "The file you uploaded is not a jpg file";
return(View());
}
else
{
db.Images.Add(imageEntity);
db.SaveChanges();
db.Images.Find(imageEntity.Id).Uri = ImageStorage.ImageURI(Url, imageEntity.Id);
db.SaveChanges();
ImageStorage.SaveFile(Server, ImageFile, imageEntity.Id);
// string imgFileName = Server.MapPath("~/Content/Images/img-" + imageEntity.Id + ".jpg");
// ImageFile.SaveAs(imgFileName);
ValidationRequest validationReq = new ValidationRequest();
validationReq.imageId = imageEntity.Id;
validationReq.UserId = user.Id;
return(RedirectToAction("Details", new { Id = imageEntity.Id }));
}
}
else
{
ViewBag.Message = "No image file specified!";
return(View());
}
}
else
{
ViewBag.Message = "Please correct the errors in the form!";
return(View());
}
}
public static ValidationResult Validate(ValidationData data)
{
ObjectBinder binder = CreateObjectBinder(data);
ValidationRequest request = new ValidationRequest(binder);
FlowErrorTrace errorTrace = data.flow.Validate(request);
ValidationResult result = new ValidationResult(errorTrace);
return(result);
}
public ActionResult View(int id, string status)
{
ViewBag.Status = status;
ValidationRequest request = db.ValidationRequests.Where(e => e.RequestID.Equals(id)).FirstOrDefault();
ViewBag.Statuses = db.ValidationStatus.ToList();
return(View(request));
}
public static void Send(ValidationRequest request)
{
if (Client == null)
{
Initialize();
}
//Send message
Client.Send(new BrokeredMessage(request));
}
public void RequestIsValid()
{
var request = new ValidationRequest
{
HttpRequest = new HttpRequestMessage
{
Properties = { { HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } },
Headers =
{
{ Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER, "TestSignatureCertChainUrlValue" },
{ Sdk.SIGNATURE_REQUEST_HEADER, "TestSignatureValue" }
},
Content = new StringContent(GenericSuccessMessage)
},
RequestTime = DateTime.UtcNow
};
var speechlet = new EmptySpeechlet();
var response = speechlet.OnRequestValidation(request);
//Need to validate no errors except for InvalidSignature since SSL Cert not supplied <see cref="SignatureVerifierTests">
Assert.True(
(response.ValidationResult & SpeechletRequestValidationResult.NoCertHeader) != SpeechletRequestValidationResult.NoCertHeader
&&
(response.ValidationResult & SpeechletRequestValidationResult.NoSignatureHeader) != SpeechletRequestValidationResult.NoSignatureHeader
&&
(response.ValidationResult & SpeechletRequestValidationResult.InvalidJson) != SpeechletRequestValidationResult.InvalidJson
&&
(response.ValidationResult & SpeechletRequestValidationResult.InvalidSpeechlet) != SpeechletRequestValidationResult.InvalidSpeechlet
&&
(response.ValidationResult & SpeechletRequestValidationResult.InvalidTimestamp) != SpeechletRequestValidationResult.InvalidTimestamp
&&
(response.ValidationResult & SpeechletRequestValidationResult.Error) != SpeechletRequestValidationResult.Error
);
}
public void RequestIsEmptyAlexaMessage()
{
var request = new ValidationRequest
{
HttpRequest = new HttpRequestMessage
{
Properties = { { HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } },
Headers =
{
{ Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER, "TestSignatureCertChainUrlValue" },
{ Sdk.SIGNATURE_REQUEST_HEADER, "TestSignatureValue" }
},
Content = new StringContent(string.Empty)
}
};
var alexaBytes = AsyncHelpers.RunSync(() => request.HttpRequest.Content.ReadAsByteArrayAsync());
var speechlet = new EmptySpeechlet();
var response = new ValidationResponse
{
ValidationResult = SpeechletRequestValidationResult.OK
};
speechlet.GetRequest(alexaBytes, ref response);
Assert.True((response.ValidationResult & SpeechletRequestValidationResult.InvalidSpeechlet) == SpeechletRequestValidationResult.InvalidSpeechlet);
}
public void TimestampRequestIsNotWithinTolerance()
{
var request = new ValidationRequest
{
HttpRequest = new HttpRequestMessage
{
Properties = { { HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } },
Headers =
{
{ Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER, "TestSignatureCertChainUrlValue" },
{ Sdk.SIGNATURE_REQUEST_HEADER, "TestSignatureValue" }
},
Content = new StringContent(OutdatedMessage)
},
RequestTime = DateTime.UtcNow
};
var speechlet = new EmptySpeechlet();
var response = speechlet.OnRequestValidation(request);
Assert.True((response.ValidationResult & SpeechletRequestValidationResult.InvalidTimestamp) ==
SpeechletRequestValidationResult.InvalidTimestamp);
}
public void TimestampIsNotWithinTolerance()
{
var request = new ValidationRequest
{
HttpRequest = new HttpRequestMessage
{
Properties = { { HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } },
Headers =
{
{ Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER, "TestSignatureCertChainUrlValue" },
{ Sdk.SIGNATURE_REQUEST_HEADER, "TestSignatureValue" }
},
Content = new StringContent(OutdatedMessage)
},
RequestTime = DateTime.UtcNow
};
var alexaBytes = AsyncHelpers.RunSync(() => request.HttpRequest.Content.ReadAsByteArrayAsync());
var alexaRequest = SpeechletRequestEnvelope.FromJson(Encoding.UTF8.GetString(alexaBytes));
var validTimestamp = SpeechletRequestTimestampVerifier.VerifyRequestTimestamp(alexaRequest, request.RequestTime);
Assert.False(validTimestamp);
}
public void HeaderContainsBlankSignatureFails()
{
var request = new ValidationRequest
{
HttpRequest = new HttpRequestMessage
{
Properties = { { HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } },
Headers =
{
{ Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER, "TestSignatureCertChainUrlValue" },
{ Sdk.SIGNATURE_REQUEST_HEADER, "" }
},
Content = new StringContent(GenericSuccessMessage)
}
};
var speechlet = new EmptySpeechlet();
var response = speechlet.OnRequestValidation(request);
Assert.True((response.ValidationResult & SpeechletRequestValidationResult.NoSignatureHeader) ==
SpeechletRequestValidationResult.NoSignatureHeader);
}
/// <summary>
/// For Testing Purposes Override Request Validation to just convert Request to Alexa Response Object
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public override ValidationResponse OnRequestValidation(ValidationRequest request)
{
var response = new ValidationResponse
{
ValidationResult = SpeechletRequestValidationResult.OK,
Success = true
};
var alexaBytes = AsyncHelpers.RunSync(() => request.HttpRequest.Content.ReadAsByteArrayAsync());
GetRequest(alexaBytes, ref response);
return response;
}
/// <summary>
/// Opportunity to set policy for handling requests with invalid signatures and/or timestamps
/// </summary>
/// <returns>Validation Response Object. Success will be true if tests pass</returns>
public virtual ValidationResponse OnRequestValidation(ValidationRequest request)
{
var response = new ValidationResponse
{
ValidationResult = SpeechletRequestValidationResult.OK
};
string chainUrl = null;
if (!request.HttpRequest.Headers.Contains(Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER) ||
String.IsNullOrEmpty(chainUrl = request.HttpRequest.Headers.GetValues(Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER).First()))
{
response.ValidationResult = response.ValidationResult | SpeechletRequestValidationResult.NoCertHeader;
}
string signature = null;
if (!request.HttpRequest.Headers.Contains(Sdk.SIGNATURE_REQUEST_HEADER) ||
String.IsNullOrEmpty(signature = request.HttpRequest.Headers.GetValues(Sdk.SIGNATURE_REQUEST_HEADER).First()))
{
response.ValidationResult = response.ValidationResult | SpeechletRequestValidationResult.NoSignatureHeader;
}
var alexaBytes = AsyncHelpers.RunSync<byte[]>(() => request.HttpRequest.Content.ReadAsByteArrayAsync());
//Debug.WriteLine(request.HttpRequest.ToLogString());
// attempt to verify signature only if we were able to locate certificate and signature headers
if (response.ValidationResult == SpeechletRequestValidationResult.OK)
{
if (!SpeechletRequestSignatureVerifier.VerifyRequestSignature(alexaBytes, signature, chainUrl))
{
response.ValidationResult = response.ValidationResult | SpeechletRequestValidationResult.InvalidSignature;
}
}
GetRequest(alexaBytes, ref response);
// attempt to verify timestamp only if we were able to parse request body
if (response.AlexaRequest != null)
{
if (!SpeechletRequestTimestampVerifier.VerifyRequestTimestamp(response.AlexaRequest, request.RequestTime))
{
response.ValidationResult = response.ValidationResult | SpeechletRequestValidationResult.InvalidTimestamp;
}
}
response.Success = (response.ValidationResult == SpeechletRequestValidationResult.OK);
return response;
}
