protected static Post SavePost(Post post) { string conn = ConfigurationManager.AppSettings["mongolab"]; PostData postData = new PostData(conn); postData.SavePost(post); return post; }
public RequestData(HttpMethod method, string path, PostData<object> data, IConnectionConfigurationValues global, IRequestConfiguration local, IMemoryStreamFactory memoryStreamFactory) { this.ConnectionSettings = global; this.MemoryStreamFactory = memoryStreamFactory; this.Method = method; this.PostData = data; this.Path = this.CreatePathWithQueryStrings(path, this.ConnectionSettings, null); this.Pipelined = global.HttpPipeliningEnabled || (local?.EnableHttpPipelining).GetValueOrDefault(false); this.HttpCompression = global.EnableHttpCompression; this.ContentType = local?.ContentType ?? MimeType; this.Headers = global.Headers; this.RequestTimeout = local?.RequestTimeout ?? global.RequestTimeout; this.PingTimeout = local?.PingTimeout ?? global?.PingTimeout ?? (global.ConnectionPool.UsingSsl ? ConnectionConfiguration.DefaultPingTimeoutOnSSL : ConnectionConfiguration.DefaultPingTimeout); this.KeepAliveInterval = (int)(global.KeepAliveInterval?.TotalMilliseconds ?? 2000); this.KeepAliveTime = (int)(global.KeepAliveTime?.TotalMilliseconds ?? 2000); this.ProxyAddress = global.ProxyAddress; this.ProxyUsername = global.ProxyUsername; this.ProxyPassword = global.ProxyPassword; this.DisableAutomaticProxyDetection = global.DisableAutomaticProxyDetection; this.BasicAuthorizationCredentials = local?.BasicAuthenticationCredentials ?? global.BasicAuthenticationCredentials; this.CancellationToken = local?.CancellationToken ?? CancellationToken.None; this.AllowedStatusCodes = local?.AllowedStatusCodes ?? Enumerable.Empty<int>(); }
protected override void OnNavigatedTo(NavigationEventArgs e) { Init(); RunAnimation(); data = (PostData)e.Parameter; base.OnNavigatedTo(e); }
public RequestData(HttpMethod method, string path, PostData<object> data, IConnectionConfigurationValues global, IRequestParameters local, IMemoryStreamFactory memoryStreamFactory) #pragma warning disable CS0618 // Type or member is obsolete : this(method, path, data, global, (IRequestConfiguration)local?.RequestConfiguration, memoryStreamFactory) #pragma warning restore CS0618 // Type or member is obsolete { this.CustomConverter = local?.DeserializationOverride; this.Path = this.CreatePathWithQueryStrings(path, this.ConnectionSettings, local); }
/// <summary> /// /// </summary> /// <returns></returns> private void PopulatePage() { bool isOk = Request.Form["minDepDate"] != null && Request.Form["maxDepDate"] != null && Request.Form["incPublicTransp"] != null && Request.Form["maxDriveKm"] != null && Request.Form["allowInter"] != null && Request.Form["outputUrl"] != null && Request.Form["iframeInputUrl"] != null; //incPublicTransp if (isOk) { bool incPublicTransp; isOk = bool.TryParse(Request.Form["incPublicTransp"], out incPublicTransp); } //maxDriveKm if (isOk) { int maxDriveKm; isOk = int.TryParse(Request.Form["maxDriveKm"], out maxDriveKm); } //allowInter if (isOk) { bool allowInter; isOk = bool.TryParse(Request.Form["allowInter"], out allowInter); } //minDepDate if (isOk) { DateTime minDepDate; isOk = DateTime.TryParseExact(Request.Form["minDepDate"], "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out minDepDate); } //maxDepDate if (isOk) { DateTime maxDepDate; isOk = DateTime.TryParseExact(Request.Form["maxDepDate"], "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out maxDepDate); } // if everything is ok with the request, // populate json objet with post data so javascript can know what's going on if (isOk) { PostData p = new PostData(); p.allowInter = bool.Parse(Request.Form["allowInter"]); p.incPublicTransp = bool.Parse(Request.Form["incPublicTransp"]); p.maxDepDate = Request.Form["maxDepDate"]; p.maxDriveKm = int.Parse(Request.Form["maxDriveKm"]); p.minDepDate = Request.Form["minDepDate"]; p.outputUrl = Request.Form["outputUrl"]; p.iframeInputUrl = Request.Form["iframeInputUrl"]; string json = JsonConvert.SerializeObject(p); litJsonRq.Text = json; } }
public async Task<IActionResult> Latest(int p = 1) { if (p <= 0) p = 1; var data = new PostData(Db); var model = await data.LatestAsync(p); if (model == null) Redirect("/"); ViewBag.PageCount = data.PageCount; ViewBag.PageNo = p; ViewBag.PagingUrl = "/Latest/{p}"; return View("Index",model); }
static PostData GetEncodedPostData(Dictionary<String, String> values, Dictionary<String, String> files) { string boundary = "----------------------------" + DateTime.Now.Ticks.ToString("x"); Stream memStream = new System.IO.MemoryStream(); byte[] boundarybytes = System.Text.Encoding.ASCII.GetBytes("\r\n--" + boundary + "\r\n"); string formdataTemplate = "\r\n--" + boundary + "\r\nContent-Disposition: form-data; name=\"{0}\";\r\n\r\n{1}"; if (values != null) foreach (var v in values) { string formitem = string.Format(formdataTemplate, v.Key, v.Value); byte[] formitembytes = System.Text.Encoding.UTF8.GetBytes(formitem); memStream.Write(formitembytes, 0, formitembytes.Length); } memStream.Write(boundarybytes, 0, boundarybytes.Length); string headerTemplate = "Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"\r\nContent-Type: application/octet-stream\r\n\r\n"; if (files != null) foreach (var v in files) { FileStream fileStream = new FileStream(v.Value, FileMode.Open, FileAccess.Read); string header = string.Format(headerTemplate, v.Key, v.Value); byte[] headerbytes = System.Text.Encoding.UTF8.GetBytes(header); memStream.Write(headerbytes, 0, headerbytes.Length); byte[] buffer = new byte[1024]; int bytesRead = 0; while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) != 0) { memStream.Write(buffer, 0, bytesRead); } memStream.Write(boundarybytes, 0, boundarybytes.Length); fileStream.Close(); } PostData result = new PostData(); memStream.Position = 0; result.data = new byte[memStream.Length]; memStream.Read(result.data, 0, result.data.Length); memStream.Close(); result.headers = "Content-Type: multipart/form-data; boundary=" + boundary + "\r\n" + "Content-Length: " + result.data.Length + "\r\n" + "\r\n"; return result; }
public async Task<IActionResult> Search(string q = "", int p = 1) { if (string.IsNullOrWhiteSpace(q)) Redirect("/"); var data = new PostData(Db); var model = await data.SearchAsync(q, p); if (model == null) Redirect("/"); ViewBag.PageCount = data.PageCount; ViewBag.PageNo = p; ViewBag.PagingUrl = $"/Search?q={q}&p={{p}}"; return View("Index", model); }
// POST api/rtpplancycle public int Post(PostData data) { var cycle = new PlanCycle() { Name = data.name, Description = data.description }; try { return TripsRepository.CreateRtpPlanCycle(cycle, data.rtpYearId); } catch (Exception ex) { Logger.WarnException("Could not create RTP Plan Cycle", ex); throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.ExpectationFailed) { ReasonPhrase = ex.Message }); } }
public async Task<IActionResult> Index(int id = 0, string slug = "") { if (id == 0 || string.IsNullOrEmpty(slug)) { return Redirect("/"); } var data = new PostData(Db); var model = await data.GetByIdAsync(id); if (model == null) Redirect("/"); return View(model); }
private void SendNotification(string appId, List<string> deviceRegIds, object notificationMessage) { WebRequest tRequest = null; GetWebRequestAndroidCloud(ref tRequest, appId, "application/json"); PostData postData = new PostData { data = notificationMessage, registration_ids = deviceRegIds }; string postDataJson = new JavaScriptSerializer().Serialize(postData); GetResponse(tRequest, postDataJson); }
// POST api/rtpproject public int Post(PostData project) { try { var id = RtpRepository.CreateProject(project.projectName, project.facilityName, project.plan, project.sponsorOrganizationId, project.cycleId); if (id <= 0) { throw new Exception("Project creation failed."); } return id; } catch (Exception ex) { Logger.WarnException("Could not create RTP Project", ex); throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.ExpectationFailed) { ReasonPhrase = "Project creation failed." }); } }
public async Task<IActionResult> Tag(int id = 0, string slug = "", int p = 1) { if (id == 0 || string.IsNullOrEmpty(slug)) { return Redirect("/"); } if (p <= 0) p = 1; var data = new PostData(Db); var model = await data.GetByTagAsync(id, p); if (model == null) Redirect("/"); ViewBag.PageCount = data.PageCount; ViewBag.PageNo = p; ViewBag.PagingUrl = $"/Tag/{id}/{slug}?p={{p}}"; return View("/Views/Home/Index", model); }
private void AddTask(PostData postData) { if (_queue == null) { _queue = new Queue<PostData>(); _thread = new System.Threading.Thread(ThreadLoop); _manualResetEvent = new System.Threading.ManualResetEvent(true); _thread.IsBackground = true; _thread.Start(); } if(!_cancel){ lock (_queue) { _queue.Enqueue(postData); } _manualResetEvent.Set(); } }
protected void Page_Load(object sender, EventArgs e) { if (!Page.IsPostBack) { string conn = ConfigurationManager.AppSettings["mongolab"]; PostData postData = new PostData(conn); string sPostId = Request.QueryString["postid"]; if (!string.IsNullOrWhiteSpace(sPostId)) { // Editing a specific Post. ObjectId postId = new ObjectId(sPostId); Post post = postData.GetPost(postId); } else { // List Posts IEnumerable<Post> posts = postData.GetAllPosts(); } } }
private RequestData( HttpMethod method, string path, PostData<object> data, IConnectionConfigurationValues global, IRequestConfiguration local, IMemoryStreamFactory memoryStreamFactory) { this.ConnectionSettings = global; this.MemoryStreamFactory = memoryStreamFactory; this.Method = method; this.PostData = data; if (data != null) data.DisableDirectStreaming = local?.DisableDirectStreaming ?? global.DisableDirectStreaming; this.Path = this.CreatePathWithQueryStrings(path, this.ConnectionSettings, null); this.Pipelined = local?.EnableHttpPipelining ?? global.HttpPipeliningEnabled; this.HttpCompression = global.EnableHttpCompression; this.ContentType = local?.ContentType ?? MimeType; this.Accept = local?.Accept ?? MimeType; this.Headers = global.Headers != null ? new NameValueCollection(global.Headers) : new NameValueCollection(); this.RunAs = local?.RunAs; this.RequestTimeout = local?.RequestTimeout ?? global.RequestTimeout; this.PingTimeout = local?.PingTimeout ?? global?.PingTimeout ?? (global.ConnectionPool.UsingSsl ? ConnectionConfiguration.DefaultPingTimeoutOnSSL : ConnectionConfiguration.DefaultPingTimeout); this.KeepAliveInterval = (int)(global.KeepAliveInterval?.TotalMilliseconds ?? 2000); this.KeepAliveTime = (int)(global.KeepAliveTime?.TotalMilliseconds ?? 2000); this.ProxyAddress = global.ProxyAddress; this.ProxyUsername = global.ProxyUsername; this.ProxyPassword = global.ProxyPassword; this.DisableAutomaticProxyDetection = global.DisableAutomaticProxyDetection; this.BasicAuthorizationCredentials = local?.BasicAuthenticationCredentials ?? global.BasicAuthenticationCredentials; this.AllowedStatusCodes = local?.AllowedStatusCodes ?? Enumerable.Empty<int>(); }
private async void NextButtonClicked(object sender, TappedRoutedEventArgs e) { var color = (ColorItem)colorGrid.SelectedItem; var name = nameBox.Text; var stick = stickNumBox.Text; var gid = gameNumBox.Text; if (color == null || string.IsNullOrEmpty(name) || string.IsNullOrEmpty(stick) || string.IsNullOrEmpty(gid)) { var message = new MessageDialog("何か忘れてませんか?", "おや?"); await message.ShowAsync(); } else { var data = new PostData(); data.color = color; data.name = name; data.stickNum = stick; data.gameId = gid; this.Frame.Navigate(typeof(InitPage02), data); } }
public ActionResult AddVideoPost(AddVideoPostInputModel model) { if (!ModelState.IsValid) { return View(); } var userData = UserManager.GetCurrentUser(); var post = new PostData { AuthorId = userData.Id, AuthorName = userData.Name, Source = VideoManager.GetYoutubeVideoId(model.Source), PostType = PostType.VideoPost, Title = model.Title, TagList = RepositoryManager.TagRepository.GetTagList(model.TagList) }; var id = RepositoryManager.PostRepository.Insert(post); return Content(Url.Action("DetailPost", "Post", new {postId = id})); }
protected virtual BaseResponse GetResults(PostData<PlayerRecordViewModel> data) { try { var commands = new FoosballCommands(); var result = commands.GetPlayerRecords().OrderByDescending(r => r.Wins).ToList(); return new GetResponse<PlayerRecordViewModel> { status = ResponseCodes.Success, total = result.Count(), records = result.Select(CreateViewModel).ToList() }; } catch (Exception ex) { return new ErrorResponse { status = ResponseCodes.Error, message = ex.Message }; } }
bool SaveData() { DataRow I = DS.invoice.Rows[0]; PostData.MarkAsTemporaryTable(DS.Tables["pettycashoperationview"], false); DS.pettycashoperation.Clear(); DS.pettycashoperationinvoice.Clear(); MetaData MetaPettycashoperation = Meta.Dispatcher.Get("pettycashoperation"); MetaPettycashoperation.SetDefaults(DS.pettycashoperation); MetaData MetaPettycashoperationinvoice = Meta.Dispatcher.Get("pettycashoperationinvoice"); MetaPettycashoperationinvoice.SetDefaults(DS.pettycashoperationinvoice); DS.pettycashoperation.Columns["idaccmotive_debit"].DefaultValue = I["idaccmotivedebit"]; DS.pettycashoperationinvoice.Columns["idinvkind"].DefaultValue = I["idinvkind"]; DS.pettycashoperationinvoice.Columns["ninv"].DefaultValue = I["ninv"]; DS.pettycashoperationinvoice.Columns["yinv"].DefaultValue = I["yinv"]; int esercizio = Convert.ToInt32(Meta.GetSys("esercizio")); foreach (DataRow R in Tpettycashoperation.Select()) { DataRow NewOp = MetaPettycashoperation.Get_New_Row(null, DS.pettycashoperation); NewOp["idpettycash"] = R["idpettycash"]; NewOp["description"] = R["description"]; NewOp["idfin"] = R["idfin"]; NewOp["idupb"] = R["idupb"]; NewOp["idman"] = R["idman"]; if (chkDocumentata.Checked) { int flag = CfgFn.GetNoNullInt32(DS.pettycashoperation.Columns["flag"].DefaultValue); NewOp["flag"] = flag; } else { int flag = CfgFn.GetNoNullInt32(DS.pettycashoperation.Columns["flag"].DefaultValue); flag = flag & 0x10; // Azzero il bit di pos.4 = Spese Documentate flag = flag & 0x08; // Azzero il bit di pos.3 = Tipo Operazione 'Spesa' flag = flag | 0x08; // Imposto il bit di pos.3 = Tipo Operazione 'Spesa' NewOp["flag"] = flag; } NewOp["amount"] = R["amount"]; NewOp["doc"] = R["doc"]; NewOp["docdate"] = R["docdate"]; NewOp["idexp"] = R["idexp"]; DataRow NewOpInvoice = MetaPettycashoperationinvoice.Get_New_Row(NewOp, DS.pettycashoperationinvoice); NewOpInvoice["yoperation"] = Meta.GetSys("esercizio"); NewOpInvoice["noperation"] = NewOp["noperation"]; NewOpInvoice["idpettycash"] = R["idpettycash"]; } PostData Post = Meta.Get_PostData(); Post.InitClass(DS, Meta.Conn); if (!Post.DO_POST()) { MessageBox.Show(this, "Si è verificato un errore o si è deciso di non salvare! L'operazione sarà terminata"); return(false); } else { GeneraScritture(); } //new FrmDettaglioRisultati(DS.pettycashoperation).ShowDialog(this); return(true); }
public RequestData(HttpMethod method, string path, PostData<object> data, IConnectionConfigurationValues global, IRequestParameters local, IMemoryStreamFactory memoryStreamFactory) : this(method, path, data, global, (IRequestConfiguration)local?.RequestConfiguration, memoryStreamFactory) { this.CustomConverter = local?.DeserializationOverride; this.Path = this.CreatePathWithQueryStrings(path, this.ConnectionSettings, local); }
///<summary>POST on /_sql/close <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/sql-pagination.html</para></summary> ///<param name = "body">Specify the cursor value in the `cursor` element to clean the cursor.</param> ///<param name = "requestParameters">Request specific configuration such as querystring parameters & request specific connection settings.</param> public TResponse ClearCursor <TResponse>(PostData body, ClearSqlCursorRequestParameters requestParameters = null) where TResponse : class, ITransportResponse, new() => DoRequest <TResponse>(POST, "_sql/close", body, RequestParams(requestParameters));
///<summary>POST on /_snapshot/{repository}/{snapshot}/_mount <para>https://www.elastic.co/guide/en/elasticsearch/reference/master/searchable-snapshots-api-mount-snapshot.html</para></summary> ///<param name = "repository">The name of the repository containing the snapshot of the index to mount</param> ///<param name = "snapshot">The name of the snapshot of the index to mount</param> ///<param name = "body">The restore configuration for mounting the snapshot as searchable</param> ///<param name = "requestParameters">Request specific configuration such as querystring parameters & request specific connection settings.</param> ///<remarks>Note: Experimental within the Elasticsearch server, this functionality is Experimental and may be changed or removed completely in a future release. Elastic will take a best effort approach to fix any issues, but experimental features are not subject to the support SLA of official GA features. This functionality is subject to potential breaking changes within a minor version, meaning that your referencing code may break when this library is upgraded.</remarks> public TResponse Mount <TResponse>(string repository, string snapshot, PostData body, MountRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new() => DoRequest <TResponse>(POST, Url($"_snapshot/{repository:repository}/{snapshot:snapshot}/_mount"), body, RequestParams(requestParameters));
public Task <TResponse> SimulatePipelineAsync <TResponse>(string id, PostData body, SimulatePipelineRequestParameters requestParameters = null, CancellationToken ctx = default) where TResponse : class, ITransportResponse, new() => DoRequestAsync <TResponse>(POST, Url($"_ingest/pipeline/{id:id}/_simulate"), ctx, body, RequestParams(requestParameters));
public Task <TResponse> ClearCursorAsync <TResponse>(PostData body, ClearSqlCursorRequestParameters requestParameters = null, CancellationToken ctx = default) where TResponse : class, ITransportResponse, new() => DoRequestAsync <TResponse>(POST, "_sql/close", ctx, body, RequestParams(requestParameters));
private async Task Store(object data) { try { var json = JsonConvert.SerializeObject(data); var result = await this.client.IndexAsync <StringResponse>("metrics", "metric", Guid.NewGuid().ToString(), PostData.String(json)); result.TryGetServerError(out var error); if (error != default(ServerError)) { throw new Exception(error.ToString()); } this.Logger.Debug($"Stored metric: {json}"); } catch (Exception ex) { this.Logger.Error(ex); } }
public void FilterThreadByPostAuthorAsync(PostData post, Action<ThreadData> action) { throw new NotImplementedException(); }
///<summary>PUT on /_snapshot/{repository} <para>https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html</para></summary> ///<param name = "repository">A repository name</param> ///<param name = "body">The repository definition</param> ///<param name = "requestParameters">Request specific configuration such as querystring parameters & request specific connection settings.</param> public TResponse CreateRepository <TResponse>(string repository, PostData body, CreateRepositoryRequestParameters requestParameters = null) where TResponse : class, ITransportResponse, new() => DoRequest <TResponse>(PUT, Url($"_snapshot/{repository:repository}"), body, RequestParams(requestParameters));
public bool InsertItem <T>(string indexName, T data) { BytesResponse res = conn.LowLevel.Index <BytesResponse>(indexName, PostData.Serializable <T>(data)); return(res.Success); }
public Task <TResponse> SnapshotAsync <TResponse>(string repository, string snapshot, PostData body, SnapshotRequestParameters requestParameters = null, CancellationToken ctx = default) where TResponse : class, ITransportResponse, new() => DoRequestAsync <TResponse>(PUT, Url($"_snapshot/{repository:repository}/{snapshot:snapshot}"), ctx, body, RequestParams(requestParameters));
///<summary>PUT on /_snapshot/{repository}/{snapshot} <para>https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html</para></summary> ///<param name = "repository">A repository name</param> ///<param name = "snapshot">A snapshot name</param> ///<param name = "body">The snapshot definition</param> ///<param name = "requestParameters">Request specific configuration such as querystring parameters & request specific connection settings.</param> public TResponse Snapshot <TResponse>(string repository, string snapshot, PostData body, SnapshotRequestParameters requestParameters = null) where TResponse : class, ITransportResponse, new() => DoRequest <TResponse>(PUT, Url($"_snapshot/{repository:repository}/{snapshot:snapshot}"), body, RequestParams(requestParameters));
private bool TryPutPipeline(ILogger logger) { if (string.IsNullOrWhiteSpace(Options.PipelineName)) { return(true); } var getPipelineResponse = Client.Ingest.GetPipeline <VoidResponse>(Options.PipelineName); if (getPipelineResponse.Success) { return(true); } var rounding = GetIndexRounding(); var pipeline = new { description = "Enriches the benchmark exports from BenchmarkDotNet", processors = new[] { new { date_index_name = new { field = "@timestamp", index_name_prefix = $"{Options.IndexName}-", // 2020-01-08T20:48:18.1548182+00:00 date_formats = new[] { "ISO8601", "yyyy-MM-dd'T'HH:mm:ss.SSSSSSSZ" }, date_rounding = rounding } } } }; var putPipeline = Client.Ingest.PutPipeline <VoidResponse>(Options.PipelineName, PostData.Serializable(pipeline)); if (putPipeline.Success) { return(true); } logger.WriteLine(putPipeline.DebugInformation); return(false); }
public async Task <ActionResult> BlockChapter(PostData data) => await BlockContent <Chapter>(data);
public static async Task <ConcurrentBag <ProductModel> > GetEsSearchableProducts() { EsClient client = new EsClient(); StringResponse searchResponse = new StringResponse(); try { searchResponse = await client.Client.SearchAsync <StringResponse>("product_search", PostData.Serializable( new { from = 0, size = 10000, query = new { match = new { type = "product" } } })); } catch (Exception ex) { Debug.WriteLine(ex.Message); Debug.WriteLine(ex.StackTrace); Debug.WriteLine(ex.InnerException.ToString()); } string responseJson = searchResponse.Body; using JsonDocument document = JsonDocument.Parse(responseJson); JsonElement root = document.RootElement; JsonElement sourceElement = root.GetProperty("hits").GetProperty("hits"); ConcurrentBag <ProductModel> products = new ConcurrentBag <ProductModel>(); Parallel.ForEach(sourceElement.EnumerateArray().AsParallel(), source => { if (source.TryGetProperty("_source", out JsonElement rec)) { ProductModel product = new ProductModel { Type = rec.GetProperty("type").GetString(), Sku = rec.GetProperty("sku").GetString(), Image = rec.GetProperty("image").GetString(), Url = rec.GetProperty("url").GetString(), Price = rec.GetProperty("price").GetDecimal(), Name = rec.GetProperty("name").GetString(), Description = rec.GetProperty("description").GetString() }; products.Add(product); } }); return(products); }
public Task <TResponse> FindStructureAsync <TResponse>(PostData body, FindStructureRequestParameters requestParameters = null, CancellationToken ctx = default) where TResponse : class, ITransportResponse, new() => DoRequestAsync <TResponse>(POST, "_text_structure/find_structure", ctx, body, RequestParams(requestParameters));
private string SendFanficRequest(object body) { return(_elasticClient.Search <StringResponse>("fullinfofanfic", "fullinfofanfic", PostData.Serializable(body)).Body); }
private PostData<object> ImplicitlyConvertsFrom(PostData<object> postData) => postData;
public void AddPost(PostData post) { }
///<summary>POST on /_sql <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/sql-rest-overview.html</para></summary> ///<param name = "body">Use the `query` element to start a query. Use the `cursor` element to continue a query.</param> ///<param name = "requestParameters">Request specific configuration such as querystring parameters & request specific connection settings.</param> public TResponse Query <TResponse>(PostData body, QuerySqlRequestParameters requestParameters = null) where TResponse : class, ITransportResponse, new() => DoRequest <TResponse>(POST, "_sql", body, RequestParams(requestParameters));
public Task <TResponse> SubmitAsync <TResponse>(string index, PostData body, AsyncSearchSubmitRequestParameters requestParameters = null, CancellationToken ctx = default) where TResponse : class, IElasticsearchResponse, new() => DoRequestAsync <TResponse>(POST, Url($"{index:index}/_async_search"), ctx, body, RequestParams(requestParameters));
public static IEnumerable<Post> GetPosts(int page=1, int pageSize=int.MaxValue) { string conn = ConfigurationManager.AppSettings["mongolab"]; PostData postData = new PostData(conn); return postData.GetAllPosts(); }
/** * The client will serialize each item seperately and join items up using the `\n` character as required by the Bulk API. Refer to the * Elasticsearch Bulk API documentation for further details and supported operations. * * [float] * === Searching * * Now that we have indexed some documents we can begin to search for them. * * The Elasticsearch Query DSL can be expressed using an anonymous type within the request */ public void SearchingWithAnonymousTypes() { var searchResponse = lowlevelClient.Search <StringResponse>("people", "person", PostData.Serializable(new { from = 0, size = 10, query = new { match = new { field = "firstName", query = "Martijn" } } })); var successful = searchResponse.Success; var responseJson = searchResponse.Body; }
public Task <TResponse> MountAsync <TResponse>(string repository, string snapshot, PostData body, MountRequestParameters requestParameters = null, CancellationToken ctx = default) where TResponse : class, IElasticsearchResponse, new() => DoRequestAsync <TResponse>(POST, Url($"_snapshot/{repository:repository}/{snapshot:snapshot}/_mount"), ctx, body, RequestParams(requestParameters));
///<summary>POST on /{index}/_async_search <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/async-search.html</para></summary> ///<param name = "index">A comma-separated list of index names to search; use the special string `_all` or Indices.All to perform the operation on all indices</param> ///<param name = "body">The search definition using the Query DSL</param> ///<param name = "requestParameters">Request specific configuration such as querystring parameters & request specific connection settings.</param> public TResponse Submit <TResponse>(string index, PostData body, AsyncSearchSubmitRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new() => DoRequest <TResponse>(POST, Url($"{index:index}/_async_search"), body, RequestParams(requestParameters));
void GeneraScritture() { if (DS.pettycashoperation.Rows.Count == 0) { return; //It was an insert-cancel } DataRow rPettycashoperation = DS.pettycashoperation.Rows[0]; // Prendo la Rows[0] perchè alcune info sono in comune alle n-pettycashoperation, quindi evito di mostrare i messaggi all'utente n volte. object idpettycash = rPettycashoperation["idpettycash"]; string filterpcash = "(idpettycash=" + QueryCreator.quotedstrvalue(idpettycash, false) + ")"; DataRow[] PettyCash = DS.pettycashsetup.Select(filterpcash); if (PettyCash.Length == 0) { MessageBox.Show("Non è stata inserita la configuraz. del fondo economale per quest'anno"); return; } DataRow rPettyCash = PettyCash[0]; object idacc_pettycash = rPettyCash["idacc"]; object idreg = rPettycashoperation["idreg"]; object idpettycashreg = rPettyCash["registrymanager"]; EP_functions EP = new EP_functions(Meta.Dispatcher); if (!EP.attivo) { return; } object idaccmot_debit = rPettycashoperation["idaccmotive_debit"]; object idacc_registry = EP.GetSupplierAccountForRegistry(null, idreg); if (idacc_registry == null || idacc_registry.ToString() == "") { MessageBox.Show("Non è stato configurato il conto di debito/credito opportuno"); return; } if (idaccmot_debit == DBNull.Value) { MessageBox.Show("Non è stata impostata la causale di debito. Sarà usata una causale di debito standard."); } foreach (DataRow Curr in DS.pettycashoperation.Rows) { EP.GetEntryForDocument(Curr); object doc = "Op. Fondo Econ. " + Curr["idpettycash"].ToString() + "/" + Curr["yoperation"].ToString().Substring(2, 2) + "/" + Curr["noperation"].ToString().PadLeft(6, '0'); EP.SetEntry(Curr["description"], Curr["adate"], doc, Curr["adate"], EP_functions.GetIdForDocument(Curr)); EP.ClearDetails(); string idepcontext_debito = "PSPESED"; decimal importo = CfgFn.GetNoNullDecimal(Curr["amount"]); //Scrittura : DEBITO A F.ECONOMALE contesto PSPESED (P.SPESE DEBITO) object idacc_debit = idacc_registry; if (idaccmot_debit != DBNull.Value) { DataRow[] ContiDebito = EP.GetAccMotiveDetails(idaccmot_debit.ToString()); if (ContiDebito.Length > 0) { idacc_debit = ContiDebito[0]["idacc"]; } } EP.EffettuaScrittura(idepcontext_debito, importo, idacc_debit.ToString(), idreg, Curr["idupb"], Curr["start"], Curr["stop"], Curr, idaccmot_debit); EP.EffettuaScrittura(idepcontext_debito, importo, idacc_pettycash.ToString(), idpettycashreg, Curr["idupb"], Curr["start"], Curr["stop"], Curr, idaccmot_debit); EP.RemoveEmptyDetails(); MetaData MetaEntry = MetaData.GetMetaData(this, "entry"); PostData Post = MetaEntry.Get_PostData(); Post.InitClass(EP.D, Meta.Conn); if (Post.DO_POST()) { EditEntry(Curr); } else { EP.viewDetails(Meta); } } }
///<summary>POST on /_async_search <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/async-search.html</para></summary> ///<param name = "body">The search definition using the Query DSL</param> ///<param name = "requestParameters">Request specific configuration such as querystring parameters & request specific connection settings.</param> public TResponse Submit <TResponse>(PostData body, AsyncSearchSubmitRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new() => DoRequest <TResponse>(POST, "_async_search", body, RequestParams(requestParameters));
public RequestData(HttpMethod method, string path, PostData<object> data, IConnectionConfigurationValues global, IMemoryStreamFactory memoryStreamFactory) : this(method, path, data, global, (IRequestConfiguration)null, memoryStreamFactory) { }
public Task <TResponse> TranslateAsync <TResponse>(PostData body, TranslateSqlRequestParameters requestParameters = null, CancellationToken ctx = default) where TResponse : class, ITransportResponse, new() => DoRequestAsync <TResponse>(POST, "_sql/translate", ctx, body, RequestParams(requestParameters));
public async Task <ActionResult> BlockBlogpost(PostData data) => await BlockContent <Blogpost>(data);
///<summary>POST on /_sql/translate <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/sql-translate.html</para></summary> ///<param name = "body">Specify the query in the `query` element.</param> ///<param name = "requestParameters">Request specific configuration such as querystring parameters & request specific connection settings.</param> public TResponse Translate <TResponse>(PostData body, TranslateSqlRequestParameters requestParameters = null) where TResponse : class, ITransportResponse, new() => DoRequest <TResponse>(POST, "_sql/translate", body, RequestParams(requestParameters));
public async Task <ActionResult> BlockStory(PostData data) => await BlockContent <Story>(data);
/// <summary> /// Asynchronously edits an existing post. /// </summary> /// <remarks> /// See: http://www.tumblr.com/docs/en/api/v2#editing /// </remarks> /// <param name="blogName"> /// The name of the blog where the post to edit is (must be one of the current user's blogs). /// </param> /// <param name="postId"> /// The identifier of the post to edit. /// </param> /// <param name="postData"> /// The data that represents the updated information for the post. See <see cref="PostData"/> for how /// to create various post types. /// </param> /// <returns> /// A <see cref="Task{T}"/> that can be used to track the operation. If the task succeeds, the <see cref="Task{T}.Result"/> will /// carry a <see cref="PostCreationInfo"/> instance. Otherwise <see cref="Task.Exception"/> will carry a <see cref="TumblrException"/> /// representing the error occurred during the call. /// </returns> /// <exception cref="ArgumentNullException"> /// <list type="bullet"> /// <item> /// <description> /// <paramref name="blogName"/> is <b>null</b>. /// </description> /// </item> /// <item> /// <description> /// <paramref name="postData"/> is <b>null</b>. /// </description> /// </item> /// </list> /// </exception> /// <exception cref="ArgumentException"> /// <list type="bullet"> /// <item> /// <description> /// <paramref name="blogName"/> is empty. /// </description> /// </item> /// <item> /// <description> /// <paramref name="postId"/> is less than 0. /// </description> /// </item> /// </list> /// </exception> /// <exception cref="InvalidOperationException"> /// This <see cref="TumblrClient"/> instance does not have an OAuth token specified. /// </exception> public Task<PostCreationInfo> EditPostAsync(string blogName, long postId, PostData postData) { return EditPostAsync(blogName, postId, postData, CancellationToken.None); }
///<summary>POST on /_text_structure/find_structure <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/find-structure.html</para></summary> ///<param name = "body">The contents of the file to be analyzed</param> ///<param name = "requestParameters">Request specific configuration such as querystring parameters & request specific connection settings.</param> public TResponse FindStructure <TResponse>(PostData body, FindStructureRequestParameters requestParameters = null) where TResponse : class, ITransportResponse, new() => DoRequest <TResponse>(POST, "_text_structure/find_structure", body, RequestParams(requestParameters));
/// <summary> /// Asynchronously edits an existing post. /// </summary> /// <remarks> /// See: http://www.tumblr.com/docs/en/api/v2#editing /// </remarks> /// <param name="blogName"> /// The name of the blog where the post to edit is (must be one of the current user's blogs). /// </param> /// <param name="postId"> /// The identifier of the post to edit. /// </param> /// <param name="postData"> /// The data that represents the updated information for the post. See <see cref="PostData"/> for how /// to create various post types. /// </param> /// <param name="cancellationToken"> /// A <see cref="CancellationToken"/> that can be used to cancel the operation. /// </param> /// <returns> /// A <see cref="Task{T}"/> that can be used to track the operation. If the task succeeds, the <see cref="Task{T}.Result"/> will /// carry a <see cref="PostCreationInfo"/> instance. Otherwise <see cref="Task.Exception"/> will carry a <see cref="TumblrException"/> /// representing the error occurred during the call. /// </returns> /// <exception cref="ObjectDisposedException"> /// The object has been disposed. /// </exception> /// <exception cref="ArgumentNullException"> /// <list type="bullet"> /// <item> /// <description> /// <paramref name="blogName"/> is <b>null</b>. /// </description> /// </item> /// <item> /// <description> /// <paramref name="postData"/> is <b>null</b>. /// </description> /// </item> /// </list> /// </exception> /// <exception cref="ArgumentException"> /// <list type="bullet"> /// <item> /// <description> /// <paramref name="blogName"/> is empty. /// </description> /// </item> /// <item> /// <description> /// <paramref name="postId"/> is less than 0. /// </description> /// </item> /// </list> /// </exception> /// <exception cref="InvalidOperationException"> /// This <see cref="TumblrClient"/> instance does not have an OAuth token specified. /// </exception> public Task<PostCreationInfo> EditPostAsync(string blogName, long postId, PostData postData, CancellationToken cancellationToken) { if (disposed) throw new ObjectDisposedException("TumblrClient"); if (blogName == null) throw new ArgumentNullException("blogName"); if (blogName.Length == 0) throw new ArgumentException("Blog name cannot be empty.", "blogName"); if (postId < 0) throw new ArgumentOutOfRangeException("postId", "Post ID must be greater or equal to zero."); if (postData == null) throw new ArgumentNullException("postData"); if (OAuthToken == null) throw new InvalidOperationException("EditPostAsync method requires an OAuth token to be specified."); var parameters = postData.ToMethodParameterSet(); parameters.Add("id", postId); return CallApiMethodAsync<PostCreationInfo>( new BlogMethod(blogName, "post/edit", OAuthToken, HttpMethod.Post, parameters), CancellationToken.None); }
private static async Task PostAssertAsync(PostData<object> postData, byte[] writes, bool storesBytes, IConnectionConfigurationValues settings) { using (var ms = new MemoryStream()) { await postData.WriteAsync(ms, settings); var sentBytes = ms.ToArray(); sentBytes.Should().Equal(writes); if (storesBytes) postData.WrittenBytes.Should().NotBeNull(); else postData.WrittenBytes.Should().BeNull(); } }
public void MarkPostAsReadAsync(PostData post) { throw new NotImplementedException(); }
/** * Indexing a single instance of this POCO, either synchronously or asynchronously, is as simple as */ public async Task Indexing() { var person = new Person { FirstName = "Martijn", LastName = "Laarman" }; var indexResponse = lowlevelClient.Index <BytesResponse>("people", "person", "1", PostData.Serializable(person)); //<1> synchronous method that returns an `IIndexResponse` byte[] responseBytes = indexResponse.Body; var asyncIndexResponse = await lowlevelClient.IndexAsync <StringResponse>("people", "person", "1", PostData.Serializable(person)); //<2> asynchronous method that returns a `Task<IIndexResponse>` that can be awaited string responseString = asyncIndexResponse.Body; }
///<summary>POST on /_ingest/pipeline/{id}/_simulate <para>https://www.elastic.co/guide/en/elasticsearch/reference/master/simulate-pipeline-api.html</para></summary> ///<param name = "id">Pipeline ID</param> ///<param name = "body">The simulate definition</param> ///<param name = "requestParameters">Request specific configuration such as querystring parameters & request specific connection settings.</param> public TResponse SimulatePipeline <TResponse>(string id, PostData body, SimulatePipelineRequestParameters requestParameters = null) where TResponse : class, ITransportResponse, new() => DoRequest <TResponse>(POST, Url($"_ingest/pipeline/{id:id}/_simulate"), body, RequestParams(requestParameters));
public void BuildPost(PostData post) { _page.AddPost(post); }
/** * NOTE: All available methods within Elasticsearch.Net are exposed as both synchronous and asynchronous versions, * with the latter using the idiomatic *Async suffix for the method name. * * Both index requests will index the document to the endpoint `/people/person/1`. * * An https://msdn.microsoft.com/en-us/library/bb397696.aspx[anonymous type] can also be used to represent the document to index */ public async Task IndexingWithAnonymousType() { var person = new { FirstName = "Martijn", LastName = "Laarman" }; var indexResponse = await lowlevelClient.IndexAsync <BytesResponse>("people", "person", "1", PostData.Serializable(person)); byte[] responseStream = indexResponse.Body; }