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); } }