public GreetingRunner(Request request, Action<Request,string> callback)
        {
            _request = request;
            _callback = callback;

            Reply();
        }
Example #2
0
 public void Setup()
 {
     _request = new Request("This is a test", new User());
     _query = new SubQuery();
     _query.InputStar.Insert(0, "first star");
     _query.InputStar.Insert(0, "second star");
 }
Example #3
0
 /// <summary>
 /// Searches for companies that match the query string.
 /// </summary>
 /// <param name="query">The query string.</param>
 /// <param name="page">The request page of the search results, giving 0 will give all results.</param>
 /// <returns>The resultset with the found company summaries.</returns>
 public static async Task<SearchResult<CompanySummary>> SearchCompanyAsync(string query, int page = 1)
 {
     var request = new Request<CompanySummary>("search/company");
     request.AddParameter("query", query.EscapeString());
     request.AddParameter("page", page);
     return await request.ProcessSearchRequestAsync();
 }
Example #4
0
 /// <summary>
 ///     Performs one-time initialization of the PROVIDER.
 /// </summary>
 /// <param name="request">
 ///     An object passed in from the CORE that contains functions that can be used to interact with
 ///     the CORE and HOST
 /// </param>
 public void InitializeProvider(Request request) {
     if( request == null ) {
         throw new ArgumentNullException("request");
     }
     // Nice-to-have put a debug message in that tells what's going on.
     request.Debug("Calling '{0}::InitializeProvider'", ProviderName);
 }
        public override Request Request(Request request)
        {
            // (collectionPointer)(key:binary)(inclusive:boolean)(pageSize:int)
            base.Request(request);

            request.OperationMode = OperationMode.Synchronous;

            // collection pointer
            request.AddDataItem(FileId);
            request.AddDataItem(PageIndex);
            request.AddDataItem(PageOffset);

            // key binary
            var cid = BinarySerializer.ToArray(FirstKey.ClusterId);
            var cpos = BinarySerializer.ToArray(FirstKey.ClusterPosition);
            byte[] orid = new byte[cid.Length + cpos.Length];
            Array.Copy(cid, orid, cid.Length);
            Array.Copy(cpos, 0, orid, cid.Length, cpos.Length);
            request.AddDataItem(orid);

            // inclusive
            request.AddDataItem((byte)(Inclusive ? 1 : 0)); // 0 - false 1 - true

            // page size
            if (OClient.ProtocolVersion >= 21)
                request.AddDataItem((int)128);

            return request;
        }
Example #6
0
 internal static string getRequest(string parentkey, string id, string proc, object[] args, bool connect_as)
 {
     if (proc == "writegroup")
     {
         List<object> newArgs = new List<object>();
         foreach (Dictionary<string, object> dict in args)
         {
             foreach (KeyValuePair<string, object> kvp in dict)
             {
                 object[] formattingArray = new object[2];
                 formattingArray[0] = kvp.Key;
                 formattingArray[1] = kvp.Value;
                 newArgs.Add(formattingArray);
             }
             args[0] = newArgs.ToArray();
         }
     }
     Call call = new Call { id = 1, procedure = proc, arguments = args };
     Call[] calls = new Call[] { call };
     Auth auth;
     if (connect_as)
     {
         auth = new Auth { cik = parentkey, client_id = id };
     }
     else
     {
         auth = new Auth { cik = parentkey, resource_id = id };
     }
     Request req = new Request { auth = auth, calls = calls };
     return JsonConvert.SerializeObject(req, Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
 }
Example #7
0
        private static AppFunc Fail(int status, string body, string headerName = null, string headerValue = null)
        {
            return env =>
                {
                    Request request = new Request(env);
                    Response response = new Response(env);
                    response.StatusCode = status;
                    response.Headers
                        .SetHeader("Content-Type", "text/plain")
                        .SetHeader("Content-Length", body.Length.ToString(CultureInfo.InvariantCulture))
                        .SetHeader("X-Cascade", "pass");

                    if (headerName != null && headerValue != null)
                    {
                        response.Headers.SetHeader(headerName, headerValue);
                    }

                    if ("HEAD".Equals(request.Method, StringComparison.OrdinalIgnoreCase))
                    {
                        return TaskHelpers.Completed();
                    }

                    return response.WriteAsync(body);
                };
        }
Example #8
0
        private HttpRequestMessage CreateHttpRequest(Request request, IAuthenticator authenticator)
        {
            var httpRequest = new HttpRequestMessage(request.Method, new Uri(request.Uri));

            if (request.Method == HttpMethod.Post || request.Method == HttpMethod.Put)
            {
                var contentRequest = request as ContentRequest;

                if (contentRequest != null && !string.IsNullOrEmpty(contentRequest.Content) && contentRequest.Encoding != null && !string.IsNullOrEmpty(contentRequest.MediaType))
                {
                    httpRequest.Content = new StringContent(contentRequest.Content, contentRequest.Encoding, contentRequest.MediaType);
                }
            }

            var headers = MergeHeaders(request.Headers, authenticator != null ? authenticator.GetHeaders(request) : null);

            if (headers != null && headers.Count > 0)
            {
                foreach (var header in headers)
                {
                    httpRequest.Headers.Add(header.Key, header.Value);
                }
            }

            return httpRequest;
        }
Example #9
0
        public void StartListening()
        {
            while (true)
            {
                using (Socket clientSocket = listeningSocket.Accept())
                {
                    IPEndPoint clientIP = clientSocket.RemoteEndPoint as IPEndPoint;
                    Debug.Print("Received request from " + clientIP.ToString());
                    var x = clientSocket.RemoteEndPoint;

                    int availableBytes = clientSocket.Available;
                    Debug.Print(DateTime.Now.ToString() + " " + availableBytes.ToString() + " request bytes available");

                    int bytesReceived = (availableBytes > maxRequestSize ? maxRequestSize : availableBytes);
                    if (bytesReceived > 0)
                    {
                        byte[] buffer = new byte[bytesReceived]; // Buffer probably should be larger than this.
                        int readByteCount = clientSocket.Receive(buffer, bytesReceived, SocketFlags.None);

                        using (Request r = new Request(clientSocket, Encoding.UTF8.GetChars(buffer)))
                        {
                            Debug.Print(DateTime.Now.ToString() + " " + r.URL);
                            if (requestReceived != null) requestReceived(r);

                        }

                    }
                }

                // I always like to have this in a continuous loop. Helps prevent lock-ups
                Thread.Sleep(10);
            }
        }
        public override Request Request(Request request)
        {
            base.Request(request);

            if (OClient.ProtocolVersion < 24)
                request.AddDataItem(ClusterType.ToString().ToUpper());

            request.AddDataItem(ClusterName);

            if (OClient.ProtocolVersion < 24)
            {
                if (OClient.ProtocolVersion >= 10 || ClusterType == OClusterType.Physical)
                    request.AddDataItem("");

                if (OClient.ProtocolVersion >= 10)
                    request.AddDataItem("default");
                else
                    request.AddDataItem((short)-1);
            }
            if (OClient.ProtocolVersion >= 18)
            {
                request.AddDataItem((short)-1); //clusterid
            }
            return request;
        }
Example #11
0
        public override Request Request(Request request)
        {
            base.Request(request);

            request.AddDataItem(ConfigKey);
            return request;
        }
        internal bool Delete(string name, string group)
        {
            var request = new Request(RequestType.Function, HttpMethod.Delete);
            request.RelativeUri = string.Join("/", _apiUri, name);

            // (optional)
            if (!string.IsNullOrEmpty(group))
            {
                request.QueryString.Add("group", group);
            }

            var response = _connection.Process(request);
            var isRemoved = false;

            switch (response.StatusCode)
            {
                case HttpStatusCode.OK:
                    isRemoved = true;
                    break;
                default:
                    if (response.IsException)
                    {
                        throw new ArangoException(
                            response.StatusCode,
                            response.Document.String("driverErrorMessage"),
                            response.Document.String("driverExceptionMessage"),
                            response.Document.Object<Exception>("driverInnerException")
                        );
                    }
                    break;
            }

            return isRemoved;
        }
Example #13
0
        /// <summary>
        /// Retrieve a Item from a custom reference.
        /// </summary>
        /// <param name="name">String containing the name of the custom reference to search for.</param>
        /// <param name="value">String containing the value of the custom reference to search for.</param>
        /// <returns>EasyPost.Item instance.</returns>
        public static Item RetrieveReference(string name, string value) {
            Request request = new Request("items/retrieve_reference/?{name}={value}");
            request.AddUrlSegment("name", name);
            request.AddUrlSegment("value", value);

            return request.Execute<Item>();
        }
Example #14
0
        public override bool Apply(Request request)
        {
            Uri u = request.Uri;
            string url = u.Host + u.PathAndQuery;
            if (u.Scheme == "connect")
                url = "https://" + url;
            else
                url = u.Scheme + "://" + url;

            foreach (KeyValuePair<string, List<RegexFilter>> kvp in hashList) {
                if (kvp.Key != "" && url.Contains (kvp.Key) == false)
                    continue;

                foreach (RegexFilter regex in kvp.Value) {

                    if (regex.IsMatch (url) == false)
                        continue;

                    request.Flags.Set (regex.Flags);
                    request.SetTriggerHtml (Html.Escape ("Adblock filter: " + regex.Pattern + "\n" + url));
                    return true;
                }
            }

            return false;
        }
Example #15
0
        /// <summary>
        /// Create a Parcel.
        /// </summary>
        /// <param name="parameters">
        /// Dictionary containing parameters to create the parcel with. Valid pairs:
        ///   * {"length", int}
        ///   * {"width", int}
        ///   * {"height", int}
        ///   * {"weight", double}
        ///   * {"predefined_package", string}
        /// All invalid keys will be ignored.
        /// </param>
        /// <returns>EasyPost.Parcel instance.</returns>
        public static Parcel Create(IDictionary<string, object> parameters)
        {
            Request request = new Request("parcels", Method.POST);
            request.addBody(parameters, "parcel");

            return request.Execute<Parcel>();
        }
        public void WorksWhenMovingToErrorQueue()
        {
            using (var messageQueue = new MsmqMessageQueue("error"))
            {
                // make sure error queue is empty
                messageQueue.PurgeInputQueue();

                adapter.Handle<Request>(req =>
                {
                    throw new ApplicationException("oh crap");
                });

                var request = new Request();
                bus.AttachHeader(request, Headers.CorrelationId, "super-unique!!!!111");
                bus.SendLocal(request);

                // let it fail
                Thread.Sleep(2.Seconds());

                var receivedTransportMessage = messageQueue.ReceiveMessage(new NoTransaction());
                receivedTransportMessage.ShouldNotBe(null);

                var serializer = new JsonMessageSerializer();
                var message = serializer.Deserialize(receivedTransportMessage);

                message.Headers.ShouldContainKeyAndValue(Headers.CorrelationId, "super-unique!!!!111");
            }
        }
Example #17
0
        private static string[] ExtractCredentialsFromHeaders(Request request)
        {
            var authorization =
                request.Headers.Authorization;

            if (string.IsNullOrEmpty(authorization))
            {
                return null;
            }

            if (!authorization.StartsWith(SCHEME))
            {
                return null;
            }

            try
            {
                var encodedUserPass = authorization.Substring(SCHEME.Length).Trim();
                var userPass = Encoding.UTF8.GetString(Convert.FromBase64String(encodedUserPass));

                return String.IsNullOrWhiteSpace(userPass) ? null : userPass.Split(':');
            }
            catch (FormatException)
            {
                return null;
            }
        }
    public SessionIdentificationData ProvideDataFromCookie(Request request, string cookieName) {
      if (request == null) throw new ArgumentNullException("request");
      if (string.IsNullOrWhiteSpace(cookieName)) throw new ArgumentNullException("cookieName");

      string cookieValue = null;
      if (!request.Cookies.TryGetValue(cookieName, out cookieValue)) {
        return null;
      }
      
      var hmacLength = Base64Helpers.GetBase64Length(_hmacProvider.HmacLength);

      if (cookieValue.Length < hmacLength) {
        // Definitely invalid
        return null;
      }

      var hmacString = cookieValue.Substring(0, hmacLength);
      var encryptedSessionId = cookieValue.Substring(hmacLength);

      byte[] hmacBytes;
      try {
        hmacBytes = Convert.FromBase64String(hmacString);
      } catch (FormatException) {
        // Invalid HMAC
        return null;
      }

      return new SessionIdentificationData {SessionId = encryptedSessionId, Hmac = hmacBytes};
    }
        public APIAccess(Request request) {
            this.req = request;

            // Okay the token we originally setup 
            // has become invalid
            if(!isValid()) RefreshToken();
        }
Example #20
0
        public static FnApp App()
        {
            return (env, fault, result) => {
                var request = new Request(env);
                var response = new Response(result);
                var wilson = "left - right\r\n123456789012\r\nhello world!\r\n";

                var href = "?flip=left";
                if (request.GET["flip"] == "left") {
                    wilson = wilson.Split(new[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries)
                        .Select(line => new string(line.Reverse().ToArray()))
                        .Aggregate("", (agg, line) => agg + line + Environment.NewLine);
                    href = "?flip=right";
                }

                response.Write("<title>Hutchtastic</title>");
                response.Write("<pre>");
                response.Write(wilson);
                response.Write("</pre>");
                if (request.GET["flip"] == "crash") {
                    throw new ApplicationException("Wilson crashed!");
                }
                response.Write("<p><a href='" + href + "'>flip!</a></p>");
                response.Write("<p><a href='?flip=crash'>crash!</a></p>");
                response.Finish();
            };
        }
Example #21
0
        public static AppDelegate App()
        {
            return call =>
            {
                var request = new Request(call);
                var response = new Response { Buffer = true, ContentType = "text/html" };
                var wilson = "left - right\r\n123456789012\r\nhello world!\r\n";

                var href = "?flip=left";
                if (request.Query["flip"] == "left")
                {
                    wilson = wilson.Split(new[] { System.Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)
                        .Select(line => new string(line.Reverse().ToArray()))
                        .Aggregate("", (agg, line) => agg + line + System.Environment.NewLine);
                    href = "?flip=right";
                }
                response.Write("<title>Wilson</title>");
                response.Write("<pre>");
                response.Write(wilson);
                response.Write("</pre>");
                if (request.Query["flip"] == "crash")
                {
                    throw new ApplicationException("Wilson crashed!");
                }
                response.Write("<p><a href='" + href + "'>flip!</a></p>");
                response.Write("<p><a href='?flip=crash'>crash!</a></p>");
                response.End();

                return response.GetResultAsync();
            };
        }
Example #22
0
        internal bool Delete(string id)
        {
            var request = new Request(RequestType.Edge, HttpMethod.Delete);
            request.RelativeUri = string.Join("/", _apiUri, id);

            var response = _connection.Process(request);
            var isRemoved = false;

            switch (response.StatusCode)
            {
                case HttpStatusCode.OK:
                case HttpStatusCode.Accepted:
                    isRemoved = true;
                    break;
                default:
                    if (response.IsException)
                    {
                        throw new ArangoException(
                            response.StatusCode,
                            response.Document.String("driverErrorMessage"),
                            response.Document.String("driverExceptionMessage"),
                            response.Document.Object<Exception>("driverInnerException")
                        );
                    }
                    break;
            }

            return isRemoved;
        }
Example #23
0
        public static MXRecord[] MXLookup(string domain, IPAddress dns_server) {
            
            // check the inputs
            if (domain == null || dns_server == null)
                throw new ArgumentNullException((domain == null) ? "dns_server" : "domain");

            // create a request for this
            Request request = new Request();

            // do the MX IN lookup for the suplied domain
            request.AddQuestion(new Question(domain, DnsType.MX, DnsClass.IN));
            Response response = Lookup(request, dns_server);

            if (response == null)
                return null;

            List<MXRecord> resource_records = new List<MXRecord>();
            foreach(Answer answer in response.Answers) {
                if (answer.Record is MXRecord) {
                    resource_records.Add(answer.Record as MXRecord);
                }
            }

            // sort into lowest preference order
            resource_records.Sort();

            return resource_records.ToArray();
        }
Example #24
0
        static void HandleRequest(Request request, Response response)
        {
            // receive HTTP content
            byte[] content = request.Stdin.GetContents();

            // access server variables
            string serverSoftware = request.ServerSoftware.GetValueOrDefault();
            string method = request.RequestMethod.Value;

            // access HTTP headers
            string userAgent = request.Headers[RequestHeader.HttpUserAgent];
            string cookieValue = request.GetCookieValue("Keks").GetValueOrDefault();

            // set HTTP headers
            response.SetHeader(ResponseHeader.HttpExpires,
                               Response.ToHttpDate(DateTime.Now.AddDays(1.0)));
            response.SetCookie(new Cookie("Keks", "yummy"));

            // send HTTP content
            response.PutStr(
                @"<html>
                   <body>
                    <p>Hello World!</p>
                    <p>Server: " + serverSoftware + @"</p>
                    <p>User Agent: " + userAgent + @"</p>
                    <p>Received cookie value: " + cookieValue + @"</p>
                    <p>Content length as read: " + content.Length + @"</P>
                    <p>Request method: " + method + @"</p>
                   </body>
                  </html>"
                );
        }
        internal ArangoCollection Get(string name)
        {
            var request = new Request(RequestType.Collection, HttpMethod.Get);
            request.RelativeUri = string.Join("/", _apiUri, name);

            var response = _connection.Process(request);
            var collection = new ArangoCollection();

            switch (response.StatusCode)
            {
                case HttpStatusCode.OK:
                    collection.Id = response.Document.String("id");
                    collection.Name = response.Document.String("name");
                    collection.Status = response.Document.Enum<ArangoCollectionStatus>("status");
                    collection.Type = response.Document.Enum<ArangoCollectionType>("type");
                    break;
                case HttpStatusCode.NotFound:
                    collection = null;
                    break;
                default:
                    if (response.IsException)
                    {
                        throw new ArangoException(
                            response.StatusCode,
                            response.Document.String("driverErrorMessage"),
                            response.Document.String("driverExceptionMessage"),
                            response.Document.Object<Exception>("driverInnerException")
                        );
                    }
                    break;
            }

            return collection;
        }
Example #26
0
        /// <summary>
        /// Create a Container.
        /// </summary>
        /// <param name="parameters">
        /// Dictionary containing parameters to create the container with. Valid pairs:
        ///   * {"name", string}
        ///   * {"type", string}
        ///   * {"reference", string}
        ///   * {"length", double}
        ///   * {"width", double}
        ///   * {"height", double}
        ///   * {"max_weight", double}
        /// All invalid keys will be ignored.
        /// </param>
        /// <returns>EasyPost.Container instance.</returns>
        public static Container Create(Dictionary<string, object> parameters)
        {
            Request request = new Request("containers", Method.POST);
            request.AddBody(parameters, "container");

            return request.Execute<Container>();
        }
Example #27
0
 public void OnFailure(Request request, Java.IO.IOException exception)
 {
     if (onFailure != null)
     {
         onFailure(request, exception);
     }
 }
Example #28
0
        public override void HandleRequest(Request request)
        {
            if (request.Message.StartsWith("~geoip") && request.RequestFrom.AccessLevel >= AccessLevel.Public)
            {
                Match expressionMatch = GeoIpRegex.Match(request.Message);

                if (expressionMatch.Success)
                {
                    try
                    {
                        ExecuteSearch(expressionMatch.Groups[1].Value, request);
                    }
                    catch (Exception ex)
                    {

                        ModuleManagementContainer.HandleResponse(request.CreateResponse(ResponseType.Public,
                                                                 "{0}, The service is currently b00rked, please try again in a few minutes.", request.Nick));
                        Logger.WarnFormat("Search threw an exception. Nick: {0}, terms: \"{1}\", stack message: {2}",
                                          request.Nick, expressionMatch.Groups[1].Value, ex.StackTrace);
                    }

                }
                else
                {
                    // If the message format isn't correct, notify the user.
                    ModuleManagementContainer.HandleResponse(request.CreateResponse(ResponseType.Public,
                                                                                    String.Format("{0}, invalid geoip syntax, please try again.",
                                                                                    request.Nick)));
                }
            }
        }
        /// <summary>
        /// Tries to handle request.
        /// </summary>
        /// <param name="request">
        /// The request.
        /// </param>
        /// <returns>
        /// The WebServer.BusinessLogic.Response.
        /// </returns>
        public override Response Handle(Request request)
        {
            if (request.HttpPath.EndsWith("/"))
            {
                string path = Configurator.Instance.RelativeWwwPath + request.HttpPath.Replace("/", "\\");
                if(!Directory.Exists(path))
                {
                    return NextHandler.Handle(request);
                }
                DirectoryInfo directory = new DirectoryInfo(path);
                List<FileSystemInfo> descendants = new List<FileSystemInfo>();
                descendants.AddRange(directory.GetFileSystemInfos());

                if (descendants.Select(desc => desc.Name).Contains("index.html"))
                {
                    request.HttpPath += "index.html";
                    return NextHandler.Handle(request);
                }

                string webPage = this.CreateWebPage(descendants, request);

                Response toReturn = new Response("text/html", request.HttpVersion, Encoding.UTF8.GetBytes(webPage));
                if (Configurator.Instance.UseResponseCompression && request.AcceptEncoding == EnumAcceptEncoding.Gzip)
                {
                    toReturn.Data = GzipCompress(toReturn.Data);
                    toReturn.ContentEncoding = "gzip";
                }

                return toReturn;
            }

            return NextHandler.Handle(request);
        }
Example #30
0
        internal Document Get(string id)
        {
            var request = new Request(RequestType.Edge, HttpMethod.Get);
            request.RelativeUri = string.Join("/", _apiUri, id);

            var response = _connection.Process(request);
            var edge = new Document();

            switch (response.StatusCode)
            {
                case HttpStatusCode.OK:
                    edge = response.Document;
                    break;
                case HttpStatusCode.NotModified:
                    edge.String("_rev", response.Headers.Get("etag").Replace("\"", ""));
                    break;
                case HttpStatusCode.NotFound:
                    edge = null;
                    break;
                default:
                    if (response.IsException)
                    {
                        throw new ArangoException(
                            response.StatusCode,
                            response.Document.String("driverErrorMessage"),
                            response.Document.String("driverExceptionMessage"),
                            response.Document.Object<Exception>("driverInnerException")
                        );
                    }
                    break;
            }

            return edge;
        }
 partial void DeleteRequest(Request instance);
Example #32
0
        public HttpResponseMessage Put(int id, [FromBody] GoldAppDoc goldappdoc)
        {
            try
            {
                using (TrustyloandbEntities entities = new TrustyloandbEntities())
                {
                    var entity = entities.GoldAppDocs.FirstOrDefault(e => e.P_ID == id);
                    if (entity == null)
                    {
                        return Request.CreateErrorResponse(HttpStatusCode.NotFound, "Person with P_Id " + id.ToString() + " Not Found!");
                    }
                    else
                    {
                        entity.Doc1_Name = goldappdoc.Doc1_Name;
                        entity.Doc1 = goldappdoc.Doc1;
                        entity.Doc2_Name = goldappdoc.Doc2_Name;
                        entity.Doc2 = goldappdoc.Doc2;
                        entity.Doc3_Name = goldappdoc.Doc3_Name;
                        entity.Doc3 = goldappdoc.Doc3;
                        entity.Doc4_Name = goldappdoc.Doc4_Name;
                        entity.Doc4 = goldappdoc.Doc4;
                        entity.Doc5_Name = goldappdoc.Doc5_Name;
                        entity.Doc5 = goldappdoc.Doc5;
                        entity.Doc6_Name = goldappdoc.Doc6_Name;
                        entity.Doc6 = goldappdoc.Doc6;
                        entity.Doc7_Name = goldappdoc.Doc7_Name;
                        entity.Doc7 = goldappdoc.Doc7;
                        entity.Doc8_Name = goldappdoc.Doc8_Name;
                        entity.Doc8 = goldappdoc.Doc8;
                        entity.Doc9_Name = goldappdoc.Doc9_Name;
                        entity.Doc9 = goldappdoc.Doc9;
                        entity.Doc10_Name = goldappdoc.Doc10_Name;
                        entity.Doc10 = goldappdoc.Doc10;
                        entity.Doc11_Name = goldappdoc.Doc11_Name;
                        entity.Doc11 = goldappdoc.Doc11;
                        entity.Doc12_Name = goldappdoc.Doc12_Name;
                        entity.Doc12 = goldappdoc.Doc12;
                        entity.Doc13_Name = goldappdoc.Doc13_Name;
                        entity.Doc13 = goldappdoc.Doc13;
                        entity.Doc14_Name = goldappdoc.Doc14_Name;
                        entity.Doc14 = goldappdoc.Doc14;
                        entity.Doc15_Name = goldappdoc.Doc15_Name;
                        entity.Doc15 = goldappdoc.Doc15;
                        entity.Doc16_Name = goldappdoc.Doc16_Name;
                        entity.Doc16 = goldappdoc.Doc16;
                        entity.Doc17_Name = goldappdoc.Doc17_Name;
                        entity.Doc17 = goldappdoc.Doc17;
                        entity.Doc18_Name = goldappdoc.Doc18_Name;
                        entity.Doc18 = goldappdoc.Doc18;
                        entity.Doc19_Name = goldappdoc.Doc19_Name;
                        entity.Doc19 = goldappdoc.Doc19;
                        entity.Doc20_Name = goldappdoc.Doc20_Name;
                        entity.Doc20 = goldappdoc.Doc20;

                        entities.SaveChanges();

                        return Request.CreateResponse(HttpStatusCode.OK);
                    }
                }
            }
            catch (Exception ex)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex);
            }
        }
 public HttpResponseMessage GetProducts(string desc)
 {
     IEnumerable<ProductDTO> productlist = _productBl.GetProduct(desc);
     HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, productlist);
     return response;
 }
 public HttpResponseMessage GetProducts()
 {
     IEnumerable<ProductDTO> Products = _productBl.GetProduct();
     HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, Products);
     return response;
 }
Example #35
0
 internal GalleryApplicationsCreateOrUpdateOperation(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, Request request, Response response)
 {
     _operation = new ArmOperationHelpers<GalleryApplication>(this, clientDiagnostics, pipeline, request, response, OperationFinalStateVia.Location, "GalleryApplicationsCreateOrUpdateOperation");
 }
 private void detach_Requests(Request entity)
 {
     this.SendPropertyChanging();
     entity.Product = null;
 }
 private void attach_Requests(Request entity)
 {
     this.SendPropertyChanging();
     entity.Product = this;
 }
 partial void InsertRequest(Request instance);
		public override Page Download(Request request, ISpider spider)
		{
			if (spider.Site == null)
			{
				return null;
			}

			Site site = spider.Site;

			var acceptStatCodes = site.AcceptStatCode;

			//Logger.InfoFormat("Downloading page {0}", request.Url);

			HttpResponseMessage response = null;
			var proxy = site.GetHttpProxyFromPool();
			request.PutExtra(Request.Proxy, proxy);
			int statusCode = 200;
			try
			{
				if (GeneratePostBody != null)
				{
					SingleExecutor.Execute(() =>
					{
						GeneratePostBody(spider.Site, request);
					});
				}

				var httpMessage = GenerateHttpRequestMessage(request, site);

				response = RedialManagerUtils.Execute("downloader-download", (m) =>
				{
					var message = (HttpRequestMessage)m;
					return httpClient.SendAsync(message).Result;
				}, httpMessage);

				AddRequestCount();

				response.EnsureSuccessStatusCode();
				if (!site.AcceptStatCode.Contains(response.StatusCode))
				{
					throw new DownloadException($"下载 {request.Url} 失败. Code: {response.StatusCode}");
				}
				statusCode = (int)response.StatusCode;
				request.PutExtra(Request.StatusCode, statusCode);

				Page page = HandleResponse(request, response, statusCode, site);

				// need update
				page.TargetUrl = request.Url.ToString();

				//page.SetRawText(File.ReadAllText(@"C:\Users\Lewis\Desktop\taobao.html"));

				// 这里只要是遇上登录的, 则在拨号成功之后, 全部抛异常在Spider中加入Scheduler调度
				// 因此如果使用多线程遇上多个Warning Custom Validate Failed不需要紧张, 可以考虑用自定义Exception分开
				ValidatePage(page, spider);

				// 结束后要置空, 这个值存到Redis会导致无限循环跑单个任务
				request.PutExtra(Request.CycleTriedTimes, null);

				//#if !NET_CORE
				//					httpWebRequest.ServicePoint.ConnectionLimit = int.MaxValue;
				//#endif

				return page;

				//正常结果在上面已经Return了, 到此处必然是下载失败的值.
				//throw new SpiderExceptoin("Download failed.");
			}
			catch (RedialException)
			{
				throw;
			}
			catch (Exception e)
			{
				Page page = new Page(request, site.ContentType) { Exception = e };

				ValidatePage(page, spider);
				throw;
			}
			finally
			{
				// 先Close Response, 避免前面语句异常导致没有关闭.
				try
				{
					//ensure the connection is released back to pool
					//check:
					//EntityUtils.consume(httpResponse.getEntity());
					response?.Dispose();
				}
				catch (Exception e)
				{
					var logger = LogUtils.GetLogger(spider);
					logger.Warn("Close response fail.", e);
				}
			}
		}
 partial void UpdateRequest(Request instance);
Example #41
0
 public IResponse <IsAliveResponse> GetIsAlive()
 {
     return(Request.Get("/isalive").Build().Execute <IsAliveResponse>());
 }
 private void detach_Requests(Request entity)
 {
     this.SendPropertyChanging();
     entity.UserAccount = null;
 }
Example #43
0
        public HttpResponseMessage GetScheme([FromUri] int id)
        {
            var scheme = _entityLogic.GetSingle(c => c.Id == id, c => c.TransactionType, c => c.Channel, c => c.Route, c => c.Fee);

            return(Request.CreateResponse(HttpStatusCode.OK, scheme));
        }
		//private HttpWebRequest GeneratorCookie(HttpWebRequest httpWebRequest, Site site)
		//{
		//	StringBuilder builder = new StringBuilder();
		//	foreach (var cookie in site.AllCookies)
		//	{
		//		builder.Append($"{cookie.Key}={cookie.Value};");
		//	}
		//	httpWebRequest.Headers.Add("Cookie", builder.ToString());

		//	return httpWebRequest;
		//}

		private HttpRequestMessage GenerateHttpRequestMessage(Request request, Site site)
		{
			if (site == null) return null;

			HttpRequestMessage httpWebRequest = CreateRequestMessage(request);
			if (!site.Headers.ContainsKey("Content-Type") && (site.Headers.ContainsKey("Content-Type") && site.Headers["Content-Type"] != "NULL"))
			{
				httpWebRequest.Headers.Add("ContentType", "application /x-www-form-urlencoded; charset=UTF-8");
			}
			else
			{
				//httpWebRequest.Content.Headers.Add("Content-Type", site.Headers["Content-Type"]);
			}
			if (site.Headers.ContainsKey("UserAgent"))
			{
				httpWebRequest.Headers.Add("UserAgent", site.Headers["UserAgent"]);
			}
			else
			{
				httpWebRequest.Headers.Add("User-Agent", site.UserAgent ?? "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 Safari/537.36");
			}

			if (!string.IsNullOrEmpty(request.Referer))
			{
				httpWebRequest.Headers.Add("Referer", request.Referer);
			}

			httpWebRequest.Headers.Add("Accept", site.Accept ?? "application/json, text/javascript, */*; q=0.01");

			if (!site.Headers.ContainsKey("Accept-Language"))
			{
				httpWebRequest.Headers.Add("Accept-Language", "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3");
			}

			if (site.IsUseGzip)
			{
				httpWebRequest.Headers.Add("Accept-Encoding", "gzip");
			}


			//httpWebRequest.Timeout = site.Timeout;
			//httpWebRequest.ReadWriteTimeout = site.Timeout;
			//httpWebRequest.AllowAutoRedirect = true;

			// headers
			if (site.Headers != null)
			{
				foreach (var header in site.Headers)
				{
					if (!string.IsNullOrEmpty(header.Key) && !string.IsNullOrEmpty(header.Value) && header.Key != "Content-Type" && header.Key != "User-Agent")
					{
						httpWebRequest.Headers.Add(header.Key, header.Value);
					}
				}
			}
			httpWebRequest.Headers.Add("Cookie", site.Cookie);

			if (httpWebRequest.Method == HttpMethod.Post)
			{
				var data = string.IsNullOrEmpty(site.EncodingName) ? Encoding.UTF8.GetBytes(request.PostBody) : site.Encoding.GetBytes(request.PostBody);
				httpWebRequest.Content = new StreamContent(new MemoryStream(data));

				if (site.Headers.ContainsKey("Content-Type"))
				{
					httpWebRequest.Content.Headers.Add("Content-Type", site.Headers["Content-Type"]);
				}
			}
#if !NET_CORE
			//if (site.HttpProxyPoolEnable)
			//{
			//	HttpHost host = site.GetHttpProxyFromPool();
			//	httpWebRequest.Proxy = new WebProxy(host.Host, host.Port);
			//	request.PutExtra(Request.Proxy, host);
			//}
			//else
			//{
			//	// 避开Fiddler之类的代理
			//	httpWebRequest.Proxy = null;
			//}
#else
			//httpWebRequest.Proxy = null;
#endif
			return httpWebRequest;
		}
 private void LogReceiveBodyFailure(Request request, Exception error)
     => log.Warn(error, "Error in receiving request body from {Target}", request.Url.Authority);
Example #46
0
 internal SqlResourcesDeleteSqlContainerOperation(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, Request request, Response response)
 {
     _operation = new ArmOperationHelpers<Response>(this, clientDiagnostics, pipeline, request, response, OperationFinalStateVia.Location, "SqlResourcesDeleteSqlContainerOperation");
 }
 private void LogWebException(Request request, WebException error)
     => log.Warn(error.InnerException ?? error, "Failed to send request. Target = {Target}. Status = {Status}.", request.Url.Authority, error.Status);
Example #48
0
        public HttpResponseMessage GetSchemes()
        {
            var schemes = _entityLogic.GetList();

            return(Request.CreateResponse(HttpStatusCode.OK, schemes));
        }
 private void LogRequestTimeout(Request request, TimeSpan timeout)
     => log.Warn("Request timed out. Target = {Target}. Timeout = {Timeout}.", request.Url.Authority, timeout.ToPrettyString());
 private void LogSendBodyFailure(Request request, Exception error)
     => log.Warn(error, "Error in sending request body to {Target}.", request.Url.Authority);
        private async Task<Response> SendInternalAsync(Request request, WebRequestState state, TimeSpan? connectionTimeout, CancellationToken cancellationToken)
        {
            CancellationTokenRegistration registration;

            try
            {
                registration = cancellationToken.Register(state.CancelRequest);
            }
            catch (ObjectDisposedException)
            {
                return Responses.Canceled;
            }

            using (registration)
            using (state)
            {
                if (state.RequestCanceled)
                    return Responses.Canceled;

                state.Request = WebRequestFactory.Create(request, state.TimeRemaining, Settings, log);

                HttpActionStatus status;

                // Step 1: send request body if it was supplied in request.
                if (state.RequestCanceled)
                    return Responses.Canceled;

                if (request.HasBody)
                {
                    status = await connectTimeLimiter
                        .LimitConnectTime(SendRequestBodyAsync(request, state, cancellationToken), request, state, connectionTimeout)
                        .ConfigureAwait(false);

                    if (status != HttpActionStatus.Success)
                        return responseFactory.BuildFailureResponse(status, state);
                }

                // Step 2: receive response from server.
                if (state.RequestCanceled)
                    return Responses.Canceled;

                status = request.HasBody
                    ? await GetResponseAsync(request, state).ConfigureAwait(false)
                    : await connectTimeLimiter.LimitConnectTime(GetResponseAsync(request, state), request, state, connectionTimeout).ConfigureAwait(false);

                if (status != HttpActionStatus.Success)
                    return responseFactory.BuildFailureResponse(status, state);

                // Step 3 - download request body if it exists.
                if (!NeedToReadResponseBody(request, state))
                    return responseFactory.BuildSuccessResponse(state);

                if (ResponseBodyIsTooLarge(state))
                {
                    state.CancelRequestAttempt();
                    return responseFactory.BuildResponse(ResponseCode.InsufficientStorage, state);
                }

                if (state.RequestCanceled)
                    return Responses.Canceled;

                if (NeedToStreamResponseBody(state))
                {
                    state.ReturnStreamDirectly = true;
                    state.PreventNextDispose();
                    return responseFactory.BuildSuccessResponse(state);
                }

                status = await ReadResponseBodyAsync(request, state, cancellationToken)
                    .ConfigureAwait(false);

                return status == HttpActionStatus.Success
                    ? responseFactory.BuildSuccessResponse(state)
                    : responseFactory.BuildFailureResponse(status, state);
            }
        }
 private void LogConnectionFailure(Request request, WebException error)
     => log.Warn(error.InnerException ?? error,  "Connection failure. Target = {Target}. Status = {Status}.", request.Url.Authority,  error.Status);
Example #53
0
        public async Task<object> Any(GetAccessToken request)
        {
            var jwtAuthProvider = (JwtAuthProvider)AuthenticateService.GetRequiredJwtAuthProvider();

            if (jwtAuthProvider.RequireSecureConnection && !Request.IsSecureConnection)
                throw HttpError.Forbidden(ErrorMessages.JwtRequiresSecureConnection.Localize(Request));

            if (string.IsNullOrEmpty(request.RefreshToken))
                throw new ArgumentNullException(nameof(request.RefreshToken));

            JsonObject jwtPayload;
            try
            {
                jwtPayload = jwtAuthProvider.GetVerifiedJwtPayload(Request, request.RefreshToken.Split('.'));
            }
            catch (ArgumentException)
            {
                throw;
            }
            catch (Exception ex)
            {
                throw new ArgumentException(ex.Message);
            }

            if (jwtPayload == null)
                throw new ArgumentException(ErrorMessages.TokenInvalid.Localize(Request));

            jwtAuthProvider.AssertJwtPayloadIsValid(jwtPayload);

            if (jwtAuthProvider.ValidateRefreshToken != null && !jwtAuthProvider.ValidateRefreshToken(jwtPayload, Request))
                throw new ArgumentException(ErrorMessages.RefreshTokenInvalid.Localize(Request), nameof(request.RefreshToken));

            var userId = jwtPayload["sub"];

            var result = await Request.GetSessionFromSourceAsync(userId, async (authRepo, userAuth) => {
                if (await jwtAuthProvider.IsAccountLockedAsync(authRepo, userAuth))
                    throw new AuthenticationException(ErrorMessages.UserAccountLocked.Localize(Request));
            }).ConfigAwait();

            if (result == null)
                throw new NotSupportedException("JWT RefreshTokens requires a registered IUserAuthRepository or an AuthProvider implementing IUserSessionSource");
            
            var accessToken = jwtAuthProvider.CreateJwtBearerToken(Request, 
                session:result.Session, roles:result.Roles, perms:result.Permissions);

            var response = new GetAccessTokenResponse
            {
                AccessToken = accessToken
            };

            if (request.UseTokenCookie.GetValueOrDefault(jwtAuthProvider.UseTokenCookie) != true)
                return response;
            
            return new HttpResult(new GetAccessTokenResponse())
            {
                Cookies = {
                    new Cookie(Keywords.TokenCookie, accessToken, Cookies.RootPath) {
                        HttpOnly = true,
                        Secure = Request.IsSecureConnection,
                        Expires = DateTime.UtcNow.Add(jwtAuthProvider.ExpireTokensIn),
                    }
                }
            };
        }
        private async Task<HttpActionStatus> ReadResponseBodyAsync(Request request, WebRequestState state, CancellationToken cancellationToken)
        {
            try
            {
                var contentLength = (int)state.Response.ContentLength;
                if (contentLength > 0)
                {
                    state.BodyBuffer = Settings.BufferFactory(contentLength);

                    var totalBytesRead = 0;

                    // If a contentLength-sized buffer won't end up in LOH, it can be used directly to work with socket.
                    // Otherwise, it's better to use a small temporary buffer from a pool because the passed reference will be stored for a long time due to Keep-Alive.
                    if (contentLength < LOHObjectSizeThreshold)
                    {
                        while (totalBytesRead < contentLength)
                        {
                            var bytesToRead = Math.Min(contentLength - totalBytesRead, BufferSize);
                            var bytesRead = await state.ResponseStream.ReadAsync(state.BodyBuffer, totalBytesRead, bytesToRead, cancellationToken)
                                .ConfigureAwait(false);

                            if (bytesRead == 0)
                                break;

                            totalBytesRead += bytesRead;
                        }
                    }
                    else
                    {
                        using (BuffersPool.Acquire(out var buffer))
                        {
                            while (totalBytesRead < contentLength)
                            {
                                var bytesToRead = Math.Min(contentLength - totalBytesRead, buffer.Length);
                                var bytesRead = await state.ResponseStream.ReadAsync(buffer, 0, bytesToRead).ConfigureAwait(false);
                                if (bytesRead == 0)
                                    break;

                                Buffer.BlockCopy(buffer, 0, state.BodyBuffer, totalBytesRead, bytesRead);

                                totalBytesRead += bytesRead;
                            }
                        }
                    }

                    if (totalBytesRead < contentLength)
                        throw new EndOfStreamException($"Response stream ended prematurely. Read only {totalBytesRead} byte(s), but Content-Length specified {contentLength}.");

                    state.BodyBufferLength = totalBytesRead;
                }
                else
                {
                    state.BodyStream = new MemoryStream();

                    using (BuffersPool.Acquire(out var buffer))
                    {
                        while (true)
                        {
                            var bytesRead = await state.ResponseStream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
                            if (bytesRead == 0)
                                break;

                            state.BodyStream.Write(buffer, 0, bytesRead);

                            if (ResponseBodyIsTooLarge(state))
                            {
                                state.CancelRequestAttempt();
                                state.BodyStream = null;
                                return HttpActionStatus.InsufficientStorage;
                            }
                        }
                    }
                }

                return HttpActionStatus.Success;
            }
            catch (Exception error)
            {
                if (cancellationToken.IsCancellationRequested)
                    return HttpActionStatus.RequestCanceled;

                LogReceiveBodyFailure(request, error);
                return HttpActionStatus.ReceiveFailure;
            }
        }
Example #55
0
 // GET: Error
 public ActionResult UnAuthorized()
 => Request.IsAjaxRequest() ? PartialView() : View();
 internal VirtualNetworkGatewayConnectionsStopPacketCaptureOperation(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, Request request, Response response)
 {
     _operation = new ArmOperationHelpers<string>(this, clientDiagnostics, pipeline, request, response, OperationFinalStateVia.Location, "VirtualNetworkGatewayConnectionsStopPacketCaptureOperation");
 }
Example #57
0
        public HttpResponseMessage ManageAnimalSupplier()
        {
            string OrganizationOid;
            string FinanceYearOid;
            try
            {
                OrganizationOid = HttpContext.Current.Request.Form["OrganizationOid"].ToString();

                FinanceYearOid = HttpContext.Current.Request.Form["FinanceYearOid"].ToString();

                XpoTypesInfoHelper.GetXpoTypeInfoSource();
                XafTypesInfo.Instance.RegisterEntity(typeof(ManageAnimalSupplier));
                List<ManageAnimalSupplier_Model> list_detail = new List<ManageAnimalSupplier_Model>();
                XPObjectSpaceProvider directProvider = new XPObjectSpaceProvider(scc, null);
                IObjectSpace ObjectSpace = directProvider.CreateObjectSpace();

                IList<ManageAnimalSupplier> collection = ObjectSpace.GetObjects<ManageAnimalSupplier>(CriteriaOperator.Parse(" GCRecord is null and Status = 1 and OrgZoneOid=? and FinanceYearOid=?  ", OrganizationOid, FinanceYearOid));
                double Weight = 0;
                if (collection.Count > 0)
                {
                    foreach (ManageAnimalSupplier row in collection)
                    {
                        ManageAnimalSupplier_Model ManageAnimal = new ManageAnimalSupplier_Model();
                        ManageAnimal.Oid = row.Oid.ToString();
                        ManageAnimal.OrgZoneOid = row.OrgZoneOid.Oid.ToString();
                        ManageAnimal.OrgZone = row.OrgZoneOid.OrganizeNameTH;
                        ManageAnimal.OrganizationOid = row.OrganizationOid.Oid.ToString();
                        ManageAnimal.Organization = row.OrganizationOid.SubOrganizeName;
                        ManageAnimal.FinanceYearOid = row.FinanceYearOid.Oid.ToString();
                        ManageAnimal.FinanceYear = row.FinanceYearOid.YearName;
                        ManageAnimal.AnimalSupplieOid = row.AnimalSupplieOid.Oid.ToString();
                        ManageAnimal.AnimalSupplie = row.AnimalSupplieOid.AnimalSupplieName;
                        ManageAnimal.ZoneQTY = row.ZoneQTY;
                        ManageAnimal.CenterQTY = row.CenterQTY;
                        ManageAnimal.OfficeQTY = row.OfficeQTY;
                        ManageAnimal.OfficeGAPQTY = row.OfficeGAPQTY;
                        ManageAnimal.OfficeBeanQTY = row.OfficeBeanQTY;

                        List<ManageSubAnimalSupplier_Model> detail = new List<ManageSubAnimalSupplier_Model>();
                        foreach (ManageSubAnimalSupplier row2 in row.ManageSubAnimalSuppliers)
                        {
                            ManageSubAnimalSupplier_Model item = new ManageSubAnimalSupplier_Model();
                            item.ProvinceQTY = row2.ProvinceQTY;

                            item.Province = row2.ProvinceOid.ProvinceNameTH;
                            detail.Add(item);
                        }
                        ManageAnimal.Detail = detail;
                        ManageAnimal.SumProvinceQTY = row.SumProvinceQTY.Value;

                        list_detail.Add(ManageAnimal);
                    }
                    return Request.CreateResponse(HttpStatusCode.OK, list_detail);
                }
                else
                {
                    UserError err = new UserError();
                    err.code = "5"; // error จากสาเหตุอื่นๆ จะมีรายละเอียดจาก system แจ้งกลับ
                    err.message = "No data";
                    //  Return resual
                    return Request.CreateResponse(HttpStatusCode.BadRequest, err);
                }
            }
            catch (Exception ex)
            { //Error case เกิดข้อผิดพลาด
                UserError err = new UserError();
                err.code = "6"; // error จากสาเหตุอื่นๆ จะมีรายละเอียดจาก system แจ้งกลับ
                err.message = ex.Message;
                //  Return resual
                return Request.CreateResponse(HttpStatusCode.BadRequest, ex);
            }
        }
Example #58
0
        private void ProcessSingleRequest()
        {
            Request request = m_requestQueue.Dequeue();

            Debug.LogWarning("A log message from EventQueue : " + request.content);
        }
Example #59
0
 public Boolean IsMobileSession()
 {
     return((Request.IsMobileDevice() && (Request.Cookies[MFBConstants.keyClassic] == null || Request.Cookies[MFBConstants.keyClassic].Value != "yes")) ||
            (Session[MFBConstants.keyLite] != null && Session[MFBConstants.keyLite].ToString() == Boolean.TrueString));
 }
 public async Task <Response> Handle(Request request, CancellationToken cancellationToken)
 => new Response()
 {
     Note = NoteApiModel.FromNote(await _context.Notes.FindAsync(request.NoteId))
 };