public async Task AddMap()
{
Assert.True(false, "Requires refactored.");
var restClient = new Mock <IRestClient>();
restClient.Setup(r => r.BaseUrl).Returns(new Uri("http://www.blah.com"));
restClient.Setup(r => r.ExecuteTaskAsync <EndpointList>(It.IsAny <IRestRequest>()))
.Returns(() => CreateMockResponse <EndpointList>(response => response.Data = new EndpointList {
MapsUrl = "/blah"
}).ToTask());
restClient.Setup(r => r.ExecuteTaskAsync <API.Domain.Map>(It.IsAny <IRestRequest>()))
.Returns((IRestRequest r) => CreateMockResponse <API.Domain.Map>(response => response.Data = new API.Domain.Map {
Id = (r.GetBody <Map>()).Id
}).ToTask());
var responseValidator = new ResponseValidator();
var endpoints = await Endpoints.Get(restClient.Object, responseValidator);
var mapValidator = new MapValidator();
var mapConvertor = new MapConvertor();
var mapService = new MapService(new RequestBuilder(endpoints), restClient.Object, mapValidator, responseValidator, mapConvertor);
var map = new Map {
Id = 123
};
var result = await mapService.Add(map);
Assert.Equal(map.Id, result.Id);
}
public IRow <T> Update(T record)
{
var queryParameters = "valueInputOption=RAW";
var a1Notation = Utils.A1Notation(this._range);
var uri = string.Format("https://sheets.googleapis.com/v4/spreadsheets/{0}/values/{1}?{2}", this._spreadsheetId, a1Notation, queryParameters);
var request = this._connector.CreateRequest(uri);
var fields = Utils.GetFields <T>();
var payload = JsonConvert.SerializeObject(new
{
values = new[] {
fields.Select(a => a.GetValue(record, null).ToString())
}
});
var response = new ResponseValidator(this._connector.Send(request, HttpMethod.Put, payload));
response
.Status(HttpStatusCode.OK);
this.Element = record;
return(this);
}
public IRow <T> Add(T record)
{
var queryParameters = "insertDataOption=INSERT_ROWS&valueInputOption=USER_ENTERED";
var uri = string.Format("https://sheets.googleapis.com/v4/spreadsheets/{0}/values/{1}:append?{2}", this._spreadsheetId, this._name, queryParameters);
var request = this._connector.CreateRequest(uri);
var fields = Utils.GetFields <T>();
var payload = JsonConvert.SerializeObject(new
{
values = new[] {
fields.Select(a => a.GetValue(record, null))
}
});
var response = new ResponseValidator(this._connector.Send(request, HttpMethod.Post, payload));
dynamic data = response
.Status(HttpStatusCode.OK)
.Response.Data <dynamic>();
var range = (string)data.updates.updatedRange;
return(new Row <T>(this._connector, record, this._spreadsheetId, this._worksheetId, range));
}
public void ResponseNullTest()
{
if (string.IsNullOrWhiteSpace(System.Environment.GetEnvironmentVariable("RUN_TEST_COVERAGE")))
{
Request r = new Request();
Assert.Empty(ResponseValidator.Validate(r, null, string.Empty).ValidationErrors);
r.Validation = new Validation();
Assert.NotEmpty(ResponseValidator.Validate(r, null, "this is a test").ValidationErrors);
using HttpResponseMessage resp = new System.Net.Http.HttpResponseMessage(HttpStatusCode.NotFound);
Assert.NotEmpty(ResponseValidator.Validate(r, resp, "this is a test").ValidationErrors);
resp.StatusCode = HttpStatusCode.Moved;
r.Validation = new Validation {
StatusCode = 301
};
Assert.Empty(ResponseValidator.Validate(r, resp, "this is a test").ValidationErrors);
resp.StatusCode = HttpStatusCode.OK;
r.Validation.StatusCode = 200;
resp.Content = new StringContent("this is a test");
Assert.NotEmpty(ResponseValidator.Validate(r, resp, "this is a test").ValidationErrors);
r.Validation.ContentType = "text/plain";
Assert.Empty(ResponseValidator.Validate(r, resp, null).ValidationErrors);
}
}
public void Validate_MultipleBodiesSet_ReturnsSingleError(bool jsonBody, bool xmlBody, bool stringBody, string bodyList)
{
// Arrange
var validator = new ResponseValidator();
var json = jsonBody ? new JsonElement?(JsonDocument.Parse("{}").RootElement) : null;
string xml = xmlBody ? "<year>1999</year>" : null;
string str = stringBody ? "Plain text! Hooray!" : null;
var section = new Response
{
JsonBody = json,
XmlBody = xml,
StringBody = str
};
// Act
var result = validator.Validate(section, _name);
// Assert
Assert.True(result.HasErrors);
var error = Assert.Single(result.Errors);
Assert.Equal(ErrorMessageFormatter.Format($"$", $"Only one type of body can be set per response. {bodyList} are set."), error);
}
public ITable <T> GetTable <T>(string name) where T : new()
{
var fields = Encode.UrlEncode("sheetId,title");
var uri = string.Format("https://sheets.googleapis.com/v4/spreadsheets/{0}?includeGridData=false&fields=sheets.properties({1})", this._spreadsheetId, fields);
var request = this._connector.CreateRequest(uri);
var response = new ResponseValidator(this._connector.Send(request, HttpMethod.Get));
dynamic data = response
.Status(HttpStatusCode.OK)
.Response.Data <dynamic>();
var sheets = data.sheets;
if (sheets.Count > 0)
{
foreach (var sheet in sheets)
{
if (sheet.properties.title == name)
{
return(new Table <T>(this._connector, name, this._spreadsheetId, (string)sheet.properties.sheetId));
}
}
}
return(null);
}
public List <IRow <T> > GetAll()
{
var countFields = Utils.GetFields <T>().Count();
var fieldIndex = ((char)('A' + countFields)).ToString();
var range = string.Format("{0}!A2:{1}", this._name, fieldIndex);
var uri = string.Format("https://sheets.googleapis.com/v4/spreadsheets/{0}/values/{1}?fields=values&majorDimension=ROWS", this._spreadsheetId, range);
var request = this._connector.CreateRequest(uri);
var response = new ResponseValidator(this._connector.Send(request, HttpMethod.Get));
dynamic data = response
.Status(HttpStatusCode.OK)
.Response.Data <dynamic>();
JArray registros = data.values;
return(registros.Select((a, i) => new Row <T>(
this._connector,
this.DeserializeElement((JArray)a),
this._spreadsheetId,
this._worksheetId,
string.Format("{0}!A{1}:{2}{3}", this._name, i + 1, fieldIndex, i + 1))).ToList() as List <IRow <T> >);
}
protected IObservable <T> CreateObservable <T>(Endpoint endpoint, IEnumerable <HttpHeader> headers, string body = "",
ResponseValidator <T> responseValidator = null)
=> createObservable(endpoint, headers, body, async(rawData) =>
!string.IsNullOrEmpty(rawData)
? await Task.Run(() => serializer.Deserialize <T>(rawData)).ConfigureAwait(false)
: default(T),
responseValidator);
public async Task <ResponseContext> HandleAsync(RouteContext request)
{
if (Config.ValidateRequest)
{
var requestValidationStatus = RequestValidator.Validate(request);
if (!requestValidationStatus.IsSuccess)
{
return(ValidationError(requestValidationStatus));
}
}
var responseTask = GetResponseAsync(request);
var delayTask = Task.Delay(Config.Delay);
await Task.WhenAll(responseTask, delayTask);
var response = responseTask.Result;
if (Config.ValidateResponse)
{
var responseValidationStatus = ResponseValidator.Validate(response, request);
if (!responseValidationStatus.IsSuccess)
{
return(ValidationError(responseValidationStatus));
}
}
return(response);
}
private async Task InitData()
{
try
{
var processResponse = await _processManager.GetProcessesAsync();
if (ResponseValidator.Validate(processResponse))
{
ActiveProcessesList =
new ObservableCollection <Process>(
processResponse.ResponseObject.Where(p => p.Status == ProcessStatusEnum.InProgress));
}
MenuItems = new ObservableCollection <MenuItem>();
InitMenuItems();
DataSets = ServiceLocator.Current.GetInstance <ManageDataSetViewModel>().DataSets;
}
catch (Exception exception)
{
DispatcherHelper.CheckBeginInvokeOnUI(() => Messenger.Default.Send(exception));
}
finally
{
Mouse.SetCursor(Cursors.Arrow);
IsEnable = true;
}
}
public void Delete()
{
var uri = string.Format("https://sheets.googleapis.com/v4/spreadsheets/{0}:batchUpdate", this._spreadsheetId);
var request = this._connector.CreateRequest(uri);
var index = Utils.A1ToRowIndex(this._range);
var payload = JsonConvert.SerializeObject(new
{
requests = new
{
deleteDimension = new
{
range = new
{
sheetId = this._worksheetId,
dimension = "ROWS",
startIndex = index - 1,
endIndex = index,
}
}
}
});
var response = new ResponseValidator(this._connector.Send(request, HttpMethod.Post, payload));
response
.Status(HttpStatusCode.OK);
}
/// <summary>
/// Sender en <see cref="Forsendelse" /> til Meldingsformidler.
/// </summary>
/// <param name="forsendelse">
/// All informasjon, klar til å kunne sendes (mottakerinformasjon, sertifikater,
/// vedlegg mm), enten digitalt eller fysisk.
/// </param>
public async Task <Transportkvittering> SendAsync(Forsendelse forsendelse)
{
var guidUtility = new GuidUtility();
Log.Debug($"Utgående forsendelse, conversationId '{forsendelse.KonversasjonsId}', messageId '{guidUtility.MessageId}'.");
var documentBundle = AsiceGenerator.Create(forsendelse, guidUtility, Databehandler.Sertifikat, Klientkonfigurasjon);
var forretningsmeldingEnvelope = new ForretningsmeldingEnvelope(new EnvelopeSettings(forsendelse, documentBundle, Databehandler, guidUtility, Klientkonfigurasjon));
ValidateEnvelopeAndThrowIfInvalid(forretningsmeldingEnvelope, forretningsmeldingEnvelope.GetType().Name);
var transportReceipt = (Transportkvittering)await RequestHelper.SendMessage(forretningsmeldingEnvelope, documentBundle).ConfigureAwait(false);
transportReceipt.AntallBytesDokumentpakke = documentBundle.BillableBytes;
var transportReceiptXml = transportReceipt.Xml;
if (transportReceipt is TransportOkKvittering)
{
Log.Debug($"{transportReceipt}");
var responsvalidator = new ResponseValidator(forretningsmeldingEnvelope.Xml(), transportReceiptXml, CertificateValidationProperties);
responsvalidator.ValidateTransportReceipt(guidUtility);
}
else
{
Log.Error($"{transportReceipt}");
}
return(transportReceipt);
}
private IObservable <T> createObservable <T>(Endpoint endpoint,
IEnumerable <HttpHeader> headers, string body, Func <string, Task <T> > process,
ResponseValidator <T> responseValidator = null)
{
var headerList = headers as IList <HttpHeader> ?? headers.ToList();
var request = new Request(body, endpoint.Url, headerList, endpoint.Method);
return(Observable.Create <T>(async observer =>
{
T data;
try
{
var response = await sendRequest(request).ConfigureAwait(false);
await throwIfRequestFailed(request, response, headerList).ConfigureAwait(false);
data = await processResponseData(request, response, process).ConfigureAwait(false);
validateResponse(request, response, data, responseValidator);
}
catch (Exception e)
{
observer.OnError(e);
return;
}
observer.OnNext(data);
observer.OnCompleted();
}));
}
public ITable <T> Rename(string newName)
{
var uri = string.Format("https://sheets.googleapis.com/v4/spreadsheets/{0}:batchUpdate", this._spreadsheetId);
var request = this._connector.CreateRequest(uri);
var payload = JsonConvert.SerializeObject(new
{
requests = new
{
updateSheetProperties = new
{
properties = new
{
sheetId = this._worksheetId,
title = newName
},
fields = "title"
}
}
});
var response = new ResponseValidator(this._connector.Send(request, HttpMethod.Post, payload));
response
.Status(HttpStatusCode.OK);
return(this);
}
public IDatabasePermission GetPermission(string email)
{
var fields = Encode.UrlEncode("emailAddress,id,role,type");
var uri = string.Format("https://www.googleapis.com/drive/v3/files/{0}/permissions?fields=permissions({1})", this._spreadsheetId, fields);
var request = this._connector.CreateRequest(uri);
var response = new ResponseValidator(this._connector.Send(request, HttpMethod.Get));
dynamic data = response
.Status(HttpStatusCode.OK)
.Response.Data <dynamic>();
var permissions = data.permissions;
if (permissions.Count > 0)
{
foreach (var permission in permissions)
{
if (permission.emailAddress == email)
{
var role = (Role)System.Enum.Parse(typeof(Role), (string)permission.role, true);
var type = (Type)System.Enum.Parse(typeof(Type), (string)permission.type, true);
return(new DatabasePermission(this._connector, new Permission((string)permission.emailAddress, role, type), this._spreadsheetId, (string)permission.id));
}
}
}
return(null);
}
private async void LoginWithFacebook(string id, string email, string name, string profilePicture)
{
UserApiRequest user = new UserApiRequest();
user.RegisterProfileId = id;
user.Email = email;
user.Name = name;
user.ProfilePicture = new ImageApiRequest()
{
Url = profilePicture
};
user.RegisterType = (int)ERegisterType.FACEBOOK;
var response = await UserApiService.Login(user);
if (ResponseValidator.Validate(response))
{
AppStatus.UserLogged = response;
CheckUserLogged();
StopLoading();
}
else
{
StopLoading();
}
}
public async Task <string> SendEmailAsync(Guid activityId, bool issueSend, string trackingToken)
{
var jObject = new JObject();
jObject["IssueSend"] = issueSend;
if (!string.IsNullOrWhiteSpace(trackingToken))
{
jObject["TrackingToken"] = trackingToken;
}
string fullUrl = $"{ApiUrl}/emails({activityId:P})/Microsoft.Dynamics.CRM.SendEmail";
var request = new HttpRequestMessage(new HttpMethod("POST"), fullUrl)
{
Content = new StringContent(JsonConvert.SerializeObject(jObject), Encoding.UTF8, "application/json")
};
HttpResponseMessage response = await Authorization.GetHttpClient().SendAsync(request);
ResponseValidator.EnsureSuccessStatusCode(response);
string responseContent = await response.Content.ReadAsStringAsync();
JObject data = JObject.Parse(responseContent);
return(data["Subject"].ToString());
}
public async Task <List <Entity> > QualifyLeadAsync(QualifyLeadRequest action)
{
string fullUrl = $"{ApiUrl}/leads({action.LeadId:P})/Microsoft.Dynamics.CRM.QualifyLead";
JObject jObject = action.GetRequestObject();
var request = new HttpRequestMessage(new HttpMethod("POST"), fullUrl)
{
Content = new StringContent(JsonConvert.SerializeObject(jObject), Encoding.UTF8, "application/json")
};
HttpResponseMessage response = await Authorization.GetHttpClient().SendAsync(request);
ResponseValidator.EnsureSuccessStatusCode(response);
string responseContent = await response.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject <JObject>(responseContent);
List <Entity> entities = QualifyLeadResponseFormatter.GetCreatedEntities(data);
foreach (Entity entity in entities)
{
EntityDefinition entityDefinition = WebApiMetadata.GetEntityDefinition(entity.LogicalName);
string primaryKey = entityDefinition?.PrimaryIdAttribute;
if (entity.Contains(primaryKey))
{
entity.Id = Guid.Parse(entity.GetAttributeValue <string>(primaryKey));
}
}
return(entities);
}
public IDatabase CreateDatabase(string name)
{
var database = this.GetDatabase(name);
if (database != null)
{
throw new Exception("Exists a database with the same name");
}
var uri = "https://sheets.googleapis.com/v4/spreadsheets";
var request = this._connector.CreateRequest(uri);
var payload = JsonConvert.SerializeObject(new
{
properties = new
{
title = name
}
});
var response = new ResponseValidator(this._connector.Send(request, HttpMethod.Post, payload));
dynamic data = response
.Status(HttpStatusCode.OK)
.Response.Data <dynamic>();
var spreadsheetId = (string)data.spreadsheetId;
return(new Database(this._connector, spreadsheetId));
}
private async void Delete()
{
Log.Info(LogMessages.ManageDataSetDeleteCommand);
if (SelectedDataSet == null)
{
return;
}
var context = new CommonDialogViewModel
{
Buttons = ButtonsEnum.YesNo,
Header = "Delete dataset",
Content = new JContent("Are you sure to remove the following data set: " + SelectedDataSet.Name)
};
var view = new CommonDialog {
DataContext = context
};
var canClose = false;
var result = await _dialogHandler.Show(view, "RootDialog",
async (object sender, DialogClosingEventArgs args) =>
{
if (!canClose && (CommonDialogResult)args.Parameter == CommonDialogResult.Yes)
{
args.Cancel();
args.Session.UpdateContent(new ProgressDialog());
var isSuccessful = false;
var errorMessage = "";
try
{
var response = await _dataSetManager.DeleteDataSetAsync(SelectedDataSet.Name);
isSuccessful = response.IsSuccessful;
ResponseValidator.Validate(response, false);
}
catch (Exception exception)
{
isSuccessful = false;
errorMessage = exception.Message;
}
finally
{
if (!isSuccessful)
{
context.ErrorMessage = errorMessage;
context.ShowError = true;
args.Session.UpdateContent(view);
}
else
{
canClose = true;
args.Session.Close((CommonDialogResult)args.Parameter);
}
}
}
});
if ((CommonDialogResult)result == CommonDialogResult.Yes)
{
DispatcherHelper.CheckBeginInvokeOnUI(() => DataSets.Remove(SelectedDataSet));
}
}
protected IObservable <T> CreateObservable <T>(Endpoint endpoint, HttpHeader header, T entity,
SerializationReason serializationReason, IWorkspaceFeatureCollection features = null,
ResponseValidator <T> responseValidator = null)
{
var body = serializer.Serialize(entity, serializationReason, features);
return(CreateObservable(endpoint, header, body, responseValidator));
}
private static Task <SearchAvailabilityRs> InvalidRequest(ResponseValidator requestValidated)
{
return(Task.FromResult(new SearchAvailabilityRs {
Success = requestValidated.IsValid,
Errors = requestValidated.Errors,
Rooms = Enumerable.Empty <Room>()
}));
}
public async Task DisassociateAsync(Entity entity, string navigationProperty)
{
string fullUrl = ApiUrl + RequestEntityParser.GetEntityApiUrl(entity, WebApiMetadata) + "/" + navigationProperty + "/$ref";
var request = new HttpRequestMessage(new HttpMethod("DELETE"), fullUrl);
HttpResponseMessage response = await Authorization.GetHttpClient().SendAsync(request);
ResponseValidator.EnsureSuccessStatusCode(response);
}
public void Connect()
{
var uri = new Uri("http://localhost:9200");
var connectionSettings = new ConnectionSettings(uri).EnableDebugMode();
client = new ElasticClient(connectionSettings);
ResponseValidator.handleValidation(client.Ping(), "Connecting to Server");
}
public Task <ResponseContext> HandleAsync(RouteContext request)
{
var responseValidationStatus = ResponseValidator.Validate(Response, request);
return(responseValidationStatus.IsSuccess
? Task.FromResult((ResponseContext)null)
: Task.FromResult(Error(responseValidationStatus)));
}
public ResponseParser(Func <Type, IMetadataHandler> metadataHandlerFactory, Func <Type, SamlResponseParser> samlResponseParserFactory, IConfigurationManager <MetadataBase> configurationManager, IRelayStateHandler relayStateHandler, ILogProvider logProvider, ResponseValidator responseValidator)
{
this._metadataHandlerFactory = metadataHandlerFactory;
this._configurationManager = configurationManager;
this._samlResponseParserFactory = samlResponseParserFactory;
this._logProvider = logProvider;
this._responseValidator = responseValidator;
this._relayStateHandler = relayStateHandler;
}
public void SetUp()
{
this.statusCode = HttpStatusCode.OK;
this.contentType = "application/json";
this.headers = new WebHeaderCollection();
this.headers["Content-Type"] = this.contentType;
this.response = new Response(this.statusCode, this.headers, string.Empty);
this.responseValidator = new ResponseValidator(this.response);
}
public void MsgShouldNotBeValidatedAsHeaderMsg()
{
var msg = TickerMessages.TickerMsg;
var sut = new ResponseValidator();
var output = sut.IsHeaderMsg(msg);
Assert.False(output);
}
public void InfoHeaderMsgShouldBeValidatedAsHeaderMsg()
{
var msg = GeneralMessages.HeaderInfoMessage;
var sut = new ResponseValidator();
var output = sut.IsHeaderMsg(msg);
Assert.True(output);
}
public bugzilla_properties CheckConnection(BugzillaProfile profile)
{
var errors = new PluginProfileErrorCollection();
try
{
SetServerCertificateValidationCallback(profile);
var validators = new Queue<Validator>();
var connectionValidator = new ConnectionValidator(profile);
validators.Enqueue(connectionValidator);
var scriptValidator = new ScriptValidator(profile);
validators.Enqueue(scriptValidator);
var responseValidator = new ResponseValidator(profile, scriptValidator);
validators.Enqueue(responseValidator);
var deserializeValidator = new DeserializeValidator(profile, responseValidator);
validators.Enqueue(deserializeValidator);
var settingsValidator = new SettingsValidator(profile, deserializeValidator);
validators.Enqueue(settingsValidator);
var savedQueryValidator = new SavedQueryValidator(profile);
validators.Enqueue(savedQueryValidator);
while (validators.Count > 0)
{
var validator = validators.Dequeue();
validator.Execute(errors);
}
if (errors.Any())
{
throw new BugzillaPluginProfileException(profile, errors);
}
return deserializeValidator.Data;
}
catch (BugzillaPluginProfileException)
{
throw;
}
catch (Exception ex)
{
errors.Add(new PluginProfileError
{
FieldName = BugzillaProfile.ProfileField,
Message = string.Format("The connection with {0} is failed. {1}", profile, ex.Message)
});
throw new BugzillaPluginProfileException(profile, errors);
}
}
public ChristieProjectorProtocol(ISerialTransport transportDriver, byte id)
: base(transportDriver, id)
{
ResponseValidation = new ResponseValidator(Id, ValidatedData, this);
ValidatedData.PowerOnPollingSequence = new[]
{
StandardCommandsEnum.VideoMutePoll,
StandardCommandsEnum.LampHoursPoll,
StandardCommandsEnum.InputPoll
};
}
public void ProcessRequest(HttpContext context)
{
var aRequestInfo = RequestInfoProvider.GetRequestInformation();
if (HttpContext.Current.Request.Url.PathAndQuery.TrimStart('/').ToLower().StartsWith(aRequestInfo.ApplicationPath.ToLower().Trim('/'))) return;
var aliasSettingsManager = ObjectFactory.GetAliasSettingsManager(aRequestInfo);
var settings = aliasSettingsManager.Get();
if (settings.IsAliasingEnabled)
{
var aCacheDuration = 5;
this.TraceMessage("BEGIN Processing URL");
// Redirect if extensionless and no trailing forward slash. Backwards compatibility with pre 8.5.1.
if (Path.GetExtension(context.Request.AppRelativeCurrentExecutionFilePath) == string.Empty && !context.Request.AppRelativeCurrentExecutionFilePath.EndsWith("/"))
{
this.TraceMessage("Missing trailing slash, forcing a Redirect.");
context.Response.Clear();
context.Response.StatusCode = 301;
context.Response.Status = "301 Moved Permanently";
context.Response.AddHeader("Location", context.Request.Url.LocalPath + "/" + context.Request.Url.Query);
context.Response.End();
}
var aCacheKey = context.Request.Url.OriginalString + aRequestInfo.ContentLanguage.ToString();
var aMessageKey = aCacheKey + "messages";
var aRequestMessages = (List<RequestValidatorCode>)HttpRuntime.Cache[aMessageKey];
if (aRequestMessages == null)
{
IRequestValidator requestValidator = new RequestValidator();
aRequestMessages = requestValidator.validate(context.Request.Url);
HttpRuntime.Cache.Insert(aMessageKey, aRequestMessages, null, System.DateTime.UtcNow.AddMinutes(aCacheDuration), Cache.NoSlidingExpiration);
}
if (aRequestMessages.Count == 0)
{
var aTargetKey = aCacheKey + "target";
var target = (AliasData)HttpRuntime.Cache[aTargetKey];
if (target == null)
{
var requestManager = ObjectFactory.GetURLRequestManager(aRequestInfo);
target = requestManager.GetTarget(context.Request.Url, aRequestInfo.ContentLanguage) ?? new AliasData();
HttpRuntime.Cache.Insert(aTargetKey, target, null, System.DateTime.UtcNow.AddMinutes(aCacheDuration), System.Web.Caching.Cache.NoSlidingExpiration);
}
// Handle Response
var aResponseMessageKey = aCacheKey + "responsemessages";
var responseMessages = (List<ResponseValidatorCode>)HttpRuntime.Cache[aResponseMessageKey];
if (responseMessages == null)
{
IResponseValidator responseValidator = new ResponseValidator();
responseMessages = responseValidator.validate(target);
HttpRuntime.Cache.Insert(aResponseMessageKey, responseMessages, null, System.DateTime.UtcNow.AddMinutes(aCacheDuration), System.Web.Caching.Cache.NoSlidingExpiration);
}
if (responseMessages.Count == 0)
{
this.processValidResponse(context, target);
}
else
{
this.processInvalidResponse(responseMessages, context);
}
}
else
{
this.processInvalidRequest(aRequestMessages, context);
}
}
else
{
// perform look up for default documents.
processDefaultDocument(context);
}
}
