Container for data used to make requests
Inheritance: IRestRequest
Example #1
4
        public async Task<bool> IsValidKey(string key)
        {
            try
            {
                var client = new RestClient("http://" + _serverAdress);
                var request = new RestRequest("getProductKeyValid.php", Method.GET);
                request.AddParameter("productkeys_Key", key);

                request.Timeout = 5000;
                IRestResponse response = await client.ExecuteGetTaskAsync(request);
                //only throws the exception. Let target choose what to do
                if (response.ErrorException != null)
                {
                    throw response.ErrorException;
                }
                var model = Newtonsoft.Json.JsonConvert.DeserializeObject<string>(response.Content);
                //if string equals "1" the key is not activated yet
                if (model.Equals("1"))
                    return true;
                return false;
            }
            catch (Exception e)
            {
                return false;
            }
        }
        static private async Task<Images> download(string domain, string path, string pattern)
        {
            var result = new Images();
            var client = new RestClient(domain);
            var restTasks = new List<Task<IRestResponse>>();
            var response = client.Get(new RestRequest(path, Method.GET));

            foreach (Match match in Regex.Matches(response.Content, pattern))
            {
                string fileName = match.Captures[0].Value.Replace(">", "");
                result.Add(fileName, 0);
                if (!File.Exists(baseDir(path) + "\\" + fileName))
                {
                    var img = new RestRequest(path + fileName, Method.GET);
                    img.AddParameter("fileName", fileName);
                    restTasks.Add(client.ExecuteTaskAsync(img));
                }
            }

            foreach (var restTask in restTasks)
            {
                response = await restTask;
                string fileName = response.Request.Parameters[0].Value.ToString();
                result[fileName] = (int)response.StatusCode;
                if (response.StatusCode == HttpStatusCode.OK)
                {
                    var fs = File.Create(baseDir(path) + "\\" + fileName);
                    await fs.WriteAsync(response.RawBytes, 0, response.RawBytes.Length);
                    fs.Close();
                }
            }
            return result;
        }
 private static string FetchFeed(string domain, string resource)
 {
     var client = new RestClient(domain);
     var request = new RestRequest(resource);
     IRestResponse response = client.Execute(request);
     return response.Content;
 }
        public string ActivateFeature(string baseSiteUrl, string user, string password, string domain)
        {
            if (baseSiteUrl.EndsWith("/"))
                baseSiteUrl += "_api/";
            else
                baseSiteUrl += "/_api/";

            RestClient rc = new RestClient(baseSiteUrl);
            NetworkCredential nCredential = new NetworkCredential(user, password, domain);
            rc.Authenticator = new NtlmAuthenticator(nCredential);

            RestRequest request = new RestRequest("contextinfo?$select=FormDigestValue", Method.POST);
            request.AddHeader("Accept", "application/json;odata=verbose");
            request.AddHeader("Body", "");

            string returnedStr = rc.Execute(request).Content;
            int startPos = returnedStr.IndexOf("FormDigestValue", StringComparison.Ordinal) + 18;
            int length = returnedStr.IndexOf(@""",", startPos, StringComparison.Ordinal) - startPos;
            string formDigestValue = returnedStr.Substring(startPos, length);

            request = new RestRequest("web/features/add('de646322-53f3-474d-96bf-0ea3670a0722',false)", Method.POST);
            request.RequestFormat = DataFormat.Json;
            request.AddHeader("Accept", "application/json;odata=verbose");
            //request.AddHeader("Body", "");
            request.AddHeader("Content-Type", "application/json;odata=verbose");
            request.AddHeader("X-RequestDigest", formDigestValue);
            IRestResponse response = rc.Execute(request);
            string content = response.Content;

            return content;
        }
        public Project FindProject(string username, string projectName)
        {
            var gitHubApi = new GitHubApi(username, projectName);
            var request = new RestRequest(@"repos/{username}/{repository}");
            try
            {
                var responseData = gitHubApi.Execute<GitHubRepo>(request);

                string masterBranch = "master";
                if (!string.IsNullOrEmpty(responseData.Master_Branch))
                {
                    masterBranch = responseData.Master_Branch;
                }

                return new Project
                {
                     Name = responseData.Full_Name,
                     DownloadPackageUrl = new Uri(string.Format(@"https://github.com/{0}/{1}/zipball/{2}", username, projectName, masterBranch)),
                     LastModified = DateTime.UtcNow,
                     Description = responseData.Description
                };
            }
            catch (Exception ex)
            {
                this.logger.Error(ex, "An error has occured when finding project {0}/{1}", username, projectName);
                return null;
            }
        }
		public IEnumerable<Application> GetApplications()
		{
			var request = new RestRequest();
			request.Resource = "applications";

			return ExecuteGet<List<Application>>(request);
		}
Example #7
0
        /// <summary>
        /// Delete all webhooks registered for an account.
        /// </summary>
        /// <returns>True if the webhook deleted successfully.</returns>
        public bool DeleteAllWebhooks()
        {
            var request = new RestRequest(Method.DELETE);
            request.Resource = "/{accountId}/webhooks";

            return Execute<bool>(request);
        }
Example #8
0
        /// <summary>
        /// Get a listing of all event types that are available for webhooks.
        /// </summary>
        /// <returns>A list of event types and descriptions</returns>
        public List<WebhookEvents> GetWebhookEvents()
        {
            var request = new RestRequest();
            request.Resource = "/{accountId}/webhooks/events";

            return Execute<List<WebhookEvents>>(request);
        }
 public bool CheckCredentials(string email, string password)
 {
     var request = new RestRequest("api/User/CheckCredentials?email={email}&password={password}", Method.GET);
     request.AddUrlSegment("email", email);
     request.AddUrlSegment("password", password);
     return client.Execute<bool>(request).Data;
 }
        /// <summary>
        /// Authorizes app via twitch.tv. If successful redirect is generated and code is parsed
        /// </summary>
        /// <returns></returns>
        public Code authorization()
        {
            {
                var client = new RestClient(@"https://api.twitch.tv/kraken/oauth2/authorize");
                var request = new RestRequest(Method.GET);

                request.AddParameter("response_type", "code");
                request.AddParameter("client_id", ClientID);
                request.AddParameter("redirect_url", @"https://localhost");
                request.AddParameter("scope", "chat_login");
                request.AddParameter("state", state);

                var response = client.Execute(request);

                if (response.StatusCode == HttpStatusCode.OK)
                {
                    //somehow grab redirect and parse code...

                }
                else
                {
                    return null;
                }
            }
        }
Example #11
0
        static void callPhone(string phonenumber, string message)
        {
            ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(
                delegate
                {
                    return true;
                });

            var client = new RestClient("https://api.shoutpoint.com");
            var request = new RestRequest("v0/Dials/Connect", Method.POST);
            request.AddHeader("x-api-key", "SncRoqW8Lf4B4xA0nv5MH9tzKHnPfraA");
            request.AddHeader("Content-Type", "application/json");
            request.AddParameter("application/json", "{\"call\":{\"no\":" + phonenumber + ",\"caller_id_no\":\"17607183780\"}}", ParameterType.RequestBody);//16024784411
            var responce = client.Execute(request);//19492465047
            Console.WriteLine(responce);
            callobj test = JsonConvert.DeserializeObject<callobj>(responce.Content);
            var request2 = new RestRequest("v0/LiveCalls/" + test.call.id + "/Actions/HangUp", Method.POST);
            request2.AddHeader("x-api-key", "SncRoqW8Lf4B4xA0nv5MH9tzKHnPfraA");
            request2.AddHeader("Content-Type", "application/json");
            request2.AddParameter("application/json", "{\"message\":[\"" + message + "\"]}", ParameterType.RequestBody);
            var responce2 = client.Execute(request2);
            //var endcall= new RestRequest("v0/Dials/Connect", Method.POST);
            //endcall.AddHeader("x-api-key", "SncRoqW8Lf4B4xA0nv5MH9tzKHnPfraA");
            //endcall.AddHeader("Content-Type", "application/json");
        }
        public void BreakItemRoleInheritance(string listTitle, string baseSiteUrl, string user, string password, string domain)
        {
            try
            {
                RestClient RC = new RestClient(baseSiteUrl);
                NetworkCredential NCredential = new NetworkCredential(user, password, domain);
                RC.Authenticator = new NtlmAuthenticator(NCredential);

                RestRequest Request = new RestRequest("contextinfo?$select=FormDigestValue", Method.POST);
                Request.AddHeader("Accept", "application/json;odata=verbose");
                Request.AddHeader("Body", "");

                string ReturnedStr = RC.Execute(Request).Content;
                int StartPos = ReturnedStr.IndexOf("FormDigestValue") + 18;
                int length = ReturnedStr.IndexOf(@""",", StartPos) - StartPos;
                string FormDigestValue = ReturnedStr.Substring(StartPos, length);

                Request = new RestRequest("web/lists/GetByTitle('" + listTitle + "')/getItemById(12)/breakroleinheritance", Method.POST);
              //  Request = new RestRequest("web/lists/GetByTitle('" + listTitle + "')/breakroleinheritance(true)", Method.POST);
                Request.RequestFormat = DataFormat.Json;
                Request.AddHeader("Accept", "application/json;odata=verbose");
                Request.AddHeader("X-RequestDigest", FormDigestValue);
                string content = RC.Execute(Request).Content;

                //return "Permission breaked successfully";
            }
            catch (Exception)
            {

                throw;
            }
        }
        //TODO
        public AccessToken Login(string userName, string password, string state)
        {
            var client = new RestClient(@"https://api.twitch.tv/kraken/oauth2/token");
            var request = new RestRequest(Method.POST);
            request.AddHeader("Content-type", "application/json");
            request.AddBody(
                new
                {
                    client_id = ClientID,
                    client_secret = ClientSecret,
                    grant_type = "authorization_code",
                    redirect = @"https://localhost",
                    code = /*code received from redirect*/,
                    state = state
                });

            var response = client.Execute(request);

            if (response.StatusCode == HttpStatusCode.OK)
            {
                var result = JsonConvert.DeserializeObject<AccessToken>(response.Content);
                return result;
            }
            return null;
        }
 /// <summary>
 /// Returns a filtered list of Messages. The list includes paging information.
 /// Makes a GET request to the Messages List resource.
 /// </summary>
 /// <param name="options">The list filters for the request</param>
 public virtual void ListMessages(MessageListRequest options, Action<MessageResult> callback)
 {
     var request = new RestRequest();
     request.Resource = "Accounts/{AccountSid}/Messages.json";
     AddMessageListOptions(options, request);
     ExecuteAsync<MessageResult>(request, (response) => callback(response));
 }
Example #15
0
 public RestRequest CreateAccessToken()
 {
     var request = new RestRequest(Method.GET);
     request.Resource = "{version}/oauth/access_token";
     request.AddParameter("version", _version, ParameterType.UrlSegment);
     return request;
 }
Example #16
0
        private Task<dynamic> GetCore(dynamic parameters, CancellationToken ct)
        {
            return Task<dynamic>.Factory.StartNew(() => {

                this.RequiresAuthentication();

                var user = Context.CurrentUser as Identity;
                if (user == null)
                    return Negotiate.WithStatusCode(Nancy.HttpStatusCode.Unauthorized);

                List<string> responses = new List<string>();

                var client = new RestClient(Request.Url.SiteBase);
                foreach (var device in _connection.Select<Device>())
                {
                    var request = new RestRequest(DevicesProxyModule.PATH + "/.well-known/core", Method.GET);
                    request.AddUrlSegment("id", device.Id.ToString(CultureInfo.InvariantCulture));
                    request.AddParameter("SessionKey", user.Session.SessionKey);

                    var resp = client.Execute(request);

                    if (resp.StatusCode == HttpStatusCode.OK)
                        responses.Add(resp.Content);
                }

                var r = (Response)string.Join(",", responses);
                r.ContentType = "application/link-format";
                return r;
            }, ct);
        }
 protected RestRequest BuildPostRequest()
 {
     var request = new RestRequest(Method.POST);
     request.AddHeader("X-TrackerToken", m_token.Guid.ToString("N"));
     request.RequestFormat = DataFormat.Xml;
     return request;
 }
Example #18
0
 private static RestRequest GetRequest(Method method, string resource)
 {
     var request = new RestRequest(method);
     request.Resource = resource;
     request.JsonSerializer = new RestSharpJsonNetSerializer();
     return request;
 }
Example #19
0
 public List<Customer> GetCustomers()
 {
     const string resourceName = "customers";
     var request = new RestRequest(resourceName, Method.GET);
     var customers = Execute<CustomerList>(request).Customers;
     return customers;
 }
 public void GetPersons(Action<List<Person>> callback)
 {
     var client = new RestClient("https://raw.github.com/bekkopen/dotnetkurs/master/PersonPhoneApp/");
     client.AddHandler("text/plain", new JsonDeserializer());
     var request = new RestRequest("Persons.json", Method.GET) {RequestFormat = DataFormat.Json};
     client.ExecuteAsync<List<Person>>(request, response => callback(response.Data));
 }
Example #21
0
		public Task<string> Send(string method, string path, string json, CancellationToken cancelToken)
		{
			var request = new RestRequest(path, GetMethod(method));
            if (json != null)
			    request.AddParameter("application/json", json, ParameterType.RequestBody);
			return Send(request, cancelToken);
		}
Example #22
0
        public IRestResponse<MarketplaceSearchResponse> Search(string query = "", int start = 0, int count = 10)
        {
            var client = new MarketplaceClient(BaseUrl);

            var request = new RestRequest("/", Method.GET);
            request.AddHeader("Accept", "*/*");
            request.AddHeader("Accept-Enclding", "gzip,deflat,sdch");
            request.AddHeader("Cache-Control", "no-cache");
            request.AddHeader("HOST", "steamcommunity.com");

            request.AddCookie("__ngDebug", "false");
            request.AddCookie("Steam_Language", "english");
            request.AddCookie("sessionid", "MTE3OTk1OTgyNQ");
            request.AddCookie("steamCC_67_167_177_70", "US");
            request.AddCookie("__utma", "268881843.805413192.1378770011.1382167972.1382171160.10");
            request.AddCookie("__utmb", "268881843.1.10.1382171160");
            request.AddCookie("__utmc", "268881843");
            request.AddCookie("__utmz", "268881843.1382171160.10.6.utmcsr=google|utmccn=(organic)|utmcmd=organic|utmctr=(not%20provided)");
            //request.AddCookie("timezoneOffset", "-14400,0");

            //request.Timeout = 5*1000;
            request.AddHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/30.0.1599.101 Safari/537.36");

            request.AddParameter("query", query, ParameterType.GetOrPost);
            request.AddParameter("start", start, ParameterType.GetOrPost);
            request.AddParameter("count", count, ParameterType.GetOrPost);

            var response = client.Get<MarketplaceSearchResponse>(request);

            return response;
        }
        private void cargarKPIsAsignados()
        {
            RestClient client = new RestClient(ConfigurationManager.AppSettings.Get("endpoint"));
            RestRequest request = new RestRequest("kpis/indicadoresAsignados/{idRol}", Method.GET);

            request.AddUrlSegment("idRol", (string)Session["idRolSeleccionado"]);

            var response = client.Execute(request);

            string json = response.Content;

            List<KPI> listaKpis = JsonConvert.DeserializeObject<List<KPI>>(json);

            if (listaKpis != null)
            {
                DataTable tablaIndicadoresKPIAsignados = new DataTable("kpis");
                tablaIndicadoresKPIAsignados.Columns.AddRange(new DataColumn[5] {new DataColumn("ID",typeof(int)),
                new DataColumn("Descripcion",typeof(string)),
                new DataColumn("Formato",typeof(string)),
                new DataColumn("Objetivo",typeof(string)),
                new DataColumn("Periodicidad",typeof(string))
                });
                if (listaKpis.Count > 0)
                    foreach (var kpi in listaKpis)
                        tablaIndicadoresKPIAsignados.Rows.Add(kpi.KPIID, kpi.DescKpi, kpi.Formato, kpi.Objetivo, kpi.Periodicidad);

                Session["indicadoresKPIAsignados"] = tablaIndicadoresKPIAsignados;
                bindData(false);
            }
        }
        public ActionResult FacebookAuth()
        {
            if (Request.Params.AllKeys.Contains("code"))
            {
                var code = Request.Params["code"];
                var client = new RestClient("https://graph.facebook.com/oauth/access_token");
                var request = new RestRequest(Method.GET);

                //request.AddParameter("action", "access_token");
                request.AddParameter("client_id", this.ClientID);
                request.AddParameter("redirect_uri", this.FacebookCallbackUrl);
                request.AddParameter("client_secret", this.ClientSecret);
                request.AddParameter("code", code);

                var response = client.Execute(request);

                var pairResponse = response.Content.Split('&');
                var accessToken = pairResponse[0].Split('=')[1];

                client = new RestClient("https://graph.facebook.com/me");
                request = new RestRequest(Method.GET);

                request.AddParameter("access_token", accessToken);

                response = client.Execute(request);

                JObject jObject = JObject.Parse(response.Content);
            }

            return RedirectToAction("Index", "Home");
        }
Example #25
0
        /// <summary>
        /// Confirm a newly-created subscription, pre-authorzation or one-off
        /// payment. This method also checks that the resource response data includes
        /// a valid signature and will throw a {SignatureException} if the signature is
        /// invalid.
        /// </summary>
        /// <param name="requestContent">the response parameters returned by the API server</param>
        /// <returns>the confirmed resource object</returns>
        public ConfirmResource ConfirmResource(NameValueCollection requestContent)
        {
            var resource = DeserializeAndValidateRequestSignature(requestContent);

            var request = new RestRequest("confirm", Method.POST);
            request.RequestFormat = DataFormat.Json;
            request.AddBody(
                new
                    {
                        resource_id = resource.ResourceId,
                        resource_type = resource.ResourceType
                    });

            var client = new RestClient
                             {
                                 BaseUrl = new System.Uri(ApiClient.ApiUrl),
                                 UserAgent = GoCardless.UserAgent
                             };
            var serializer = new JsonSerializer
            {
                ContractResolver = new UnderscoreToCamelCasePropertyResolver(),
            };
            client.AddHandler("application/json", new NewtonsoftJsonDeserializer(serializer));
            client.Authenticator = new HttpBasicAuthenticator(GoCardless.AccountDetails.AppId, GoCardless.AccountDetails.AppSecret);
            var response = client.Execute(request);
            if (response.StatusCode != HttpStatusCode.OK)
            {
                throw new ApiException("Unexpected response : " + (int)response.StatusCode + " " + response.StatusCode);
            }

            return resource;
        }
        public bool Create(LocalRepositoryConfiguration config)
        {
            var request = new RestRequest(REPOSITORIES + "/" + config.key, Method.PUT);

            bool response = _client.Execute<LocalRepositoryConfiguration>(request, config);
            return response;
        }
Example #27
0
        protected void btnCrear_Click(object sender, EventArgs e)
        {
            if (validarCampos())
            {
                RestClient client = new RestClient(ConfigurationManager.AppSettings.Get("endpoint"));
                RestRequest request = new RestRequest("kpis/", Method.POST);

                List<DetalleFormula> formulaCompleta = new List<DetalleFormula>();

                for (int i = 0; i < formula.Count; i++)
                {
                    formulaCompleta.Add(new DetalleFormula(i, variables[i], formula[i]));
                }

                KPI kpiNuevo = new KPI(0, txtDescripcion.Text, ddlFormato.Text, Convert.ToDouble(txtObjetivo.Text), ddlPeriodicidad.Text, new ParametroKPI(Convert.ToInt32(ddlLimiteInf.Text), Convert.ToInt32(ddlLimiteSup.Text)), formulaCompleta);

                request.AddJsonBody(kpiNuevo);

                var response = client.Execute(request);

                formula = new List<string>();
                variables = new List<string>();
                operador = false;

                Response.Redirect("indicadoresKPI.aspx");
            }
            else
            {
                //"error"
            }
        }
        /// <summary>
        /// This example uses the raw JSON string to create a POST
        /// request for sending one or more SMTP messages through Email-On-Demand.
        /// 
        /// The JSON request generated by this sample code looks like this:
        /// 
        ///{
        ///    "ServerId": "YOUR SERVER ID HERE",
        ///    "ApiKey": "YOUR API KEY HERE",
        ///    "Messages": [{
        ///        "Subject": "Email subject line for raw JSON example.",
        ///        "TextBody": "The text portion of the message.",
        ///        "HtmlBody": "<h1>The html portion of the message</h1><br/>Test",
        ///        "To": [{
        ///            "EmailAddress": "*****@*****.**",
        ///            "FriendlyName": "Customer Name"
        ///        }],
        ///        "From": {
        ///            "EmailAddress": "*****@*****.**",
        ///            "FriendlyName": "From Address"
        ///        },
        ///    }]
        ///}
        /// </summary>
        public static void SimpleInjectionViaStringAsJson(
            int serverId, string yourApiKey, string apiUrl)
        {
            // The client object processes requests to the SocketLabs Injection API.
            var client = new RestClient(apiUrl);

            // Construct the string used to generate JSON for the POST request.
            string stringBody =
                "{" +
                    "\"ServerId\":\"" + serverId + "\"," +
                    "\"ApiKey\":\"" + yourApiKey + "\"," +
                    "\"Messages\":[{" +
                        "\"Subject\":\"Email subject line for raw JSON example.\"," +
                        "\"TextBody\":\"The text portion of the message.\"," +
                        "\"HtmlBody\":\"<h1>The html portion of the message</h1><br/>Test\"," +
                        "\"To\":[{" +
                            "\"EmailAddress\":\"[email protected]\"," +
                            "\"FriendlyName\":\"Customer Name\"" +
                        "}]," +
                        "\"From\":{" +
                            "\"EmailAddress\":\"[email protected]\"," +
                            "\"FriendlyName\":\"From Address\"" +
                        "}," +
                    "}]" +
                "}";

            try
            {
                // Generate a new POST request.
                var request = new RestRequest(Method.POST) { RequestFormat = DataFormat.Json };

                // Store the request data in the request object.
                request.AddParameter("application/json; charset=utf-8", stringBody, ParameterType.RequestBody);

                // Make the POST request.
                var result = client.ExecuteAsPost(request, "POST");

                // Store the response result in our custom class.
                using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(result.Content)))
                {
                    var serializer = new DataContractJsonSerializer(typeof (PostResponse));
                    var resp = (PostResponse) serializer.ReadObject(stream);

                    // Display the results.
                    if (resp.ErrorCode.Equals("Success"))
                    {
                        Console.WriteLine("Successful injection!");
                    }
                    else
                    {
                        Console.WriteLine("Failed injection! Returned JSON is: ");
                        Console.WriteLine(result.Content);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error, something bad happened: " + ex.Message);
            }
        }
        /// <summary>
        /// Sends the formatted messages.
        /// </summary>
        /// <param name="messages">The messages to send.</param>
        /// <param name="succeededAction">A success action that should be called for successfully sent messages.</param>
        /// <param name="failedAction">A failure action that should be called when a message send operation fails.</param>
        public void Send(IEnumerable<ProviderNotificationMessage> messages, 
            Action<ProviderNotificationMessage> succeededAction, 
            Action<ProviderNotificationMessage, Exception> failedAction)
        {
            foreach (var message in messages)
            {
                try
                {
                    // create a new rest request and add the message to the http message body
                    var request = new RestRequest(Method.POST);
                    request.AddJsonBody(message);

                    // send the POST request and call success action if everything went fine
                    _client.Post<ProviderNotificationMessage>(request);
                    if (succeededAction != null)
                        succeededAction(message);
                }
                catch(Exception e)
                {
                    // if the post fails call the failedAction
                    if(failedAction != null)
                        failedAction(message, e);
                }
            }
        }
        /// <summary>Creates new card registration data.</summary>
        /// <param name="cardRegistration">Card registration data object to create.</param>
        /// <returns>Card registration object returned from API.</returns>
        public CardRegistrationDataDTO RegisterCardData(CardRegistrationDataPostDTO cardRegistrationData)
        {
            var client = new RestClient(cardRegistrationData.CardRegistrationURL);

            var request = new RestRequest(Method.POST);
            request.AddParameter(Constants.DATA, cardRegistrationData.PreregistrationData);
            request.AddParameter(Constants.ACCESS_KEY_REF, cardRegistrationData.AccessKey);
            request.AddParameter(Constants.CARD_NUMBER, cardRegistrationData.CardNumber);
            request.AddParameter(Constants.CARD_EXPIRATION_DATE, cardRegistrationData.CardExpirationDate);
            request.AddParameter(Constants.CARD_CVX, cardRegistrationData.CardCvx);

            var response = client.Execute(request);

            var responseString = response.Content;

            if (response.StatusCode == HttpStatusCode.OK)
            {
                var cardRegistrationDataDTO = new CardRegistrationDataDTO
                {
                    RegistrationData = responseString
                };
                return cardRegistrationDataDTO;
            }
            else
                throw new Exception(responseString);
        }
Example #31
0
        public JsonResult GetAiQiYiURL(string voteid, bool repeatget = true)
        {
            VideoInfo videoInfo = null;

            _iqiyiclient = new RestSharp.RestClient("http://openapi.iqiyi.com");
            _iqiyiclient.AddHandler("application/json", new RestSharp.Deserializers.JsonDeserializer());
            if (DateTime.Now > overDate || tokeninfo == null)
            {
                var req = new RestSharp.RestRequest("/api/iqiyi/authorize", RestSharp.Method.GET);
                //接口参数
                req.AddParameter("client_id", clientid);
                req.AddParameter("client_secret", clientsecret);

                try
                {
                    var response = _iqiyiclient.Execute(req);
                    if (response.StatusCode == HttpStatusCode.OK)
                    {
                        var json = response.Content.Replace("\\", "");
                        json = json.Substring(1, json.Length - 2);

                        var data = Newtonsoft.Json.JsonConvert.DeserializeObject <BaseInfo <TokenInfo> >(json);
                        if (data != null && data.code == "A00000")
                        {
                            overDate  = DateTime.Now.AddSeconds(data.data.expires_in);
                            tokeninfo = data.data;
                        }
                    }
                    else
                    {
                        return(Json(videoInfo, JsonRequestBehavior.AllowGet));
                    }
                }
                catch (Exception ex)
                {
                    return(Json(videoInfo, JsonRequestBehavior.AllowGet));
                }
            }
            if (tokeninfo != null)
            {
                var req = new RestSharp.RestRequest("/api/file/fullStatus", RestSharp.Method.GET);
                //接口参数
                req.AddParameter("access_token", tokeninfo.access_token);
                req.AddParameter("file_id", voteid);
                try
                {
                    var response = _iqiyiclient.Execute(req);
                    if (response.StatusCode == HttpStatusCode.OK)
                    {
                        var json = response.Content.Replace("\\", "");
                        json = json.Substring(1, json.Length - 2);
                        var data = Newtonsoft.Json.JsonConvert.DeserializeObject <BaseInfo <VideoInfo> >(json);
                        if (data != null && data.code == "A00000")
                        {
                            data.data.m3u896 = data.data.urllist.m3u8[96].ToString();

                            var mp4Client = new RestSharp.RestClient();
                            mp4Client.AddHandler("application/json", new RestSharp.Deserializers.JsonDeserializer());
                            var reqmp4         = new RestSharp.RestRequest(data.data.urllist.mp4[2], RestSharp.Method.GET);
                            var repsonsemp4url = mp4Client.Execute(reqmp4);
                            try
                            {
                                if (repsonsemp4url.StatusCode == HttpStatusCode.OK)
                                {
                                    json = repsonsemp4url.Content;
                                    var i = json.IndexOf('{');
                                    var f = json.LastIndexOf(";");
                                    json = json.Substring(i, f - i);
                                    var mp4urldata = Newtonsoft.Json.JsonConvert.DeserializeObject <BaseInfo <MP4Info> >(json);
                                    if (mp4urldata.code == "A00000")
                                    {
                                        data.data.mp42 = mp4urldata.data.l;
                                    }
                                    else
                                    {
                                        data.data.mp42 = "";
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                //_logger.Error("获取MP4地址错误1:" + ex.ToString());
                                throw ex;
                            }

                            videoInfo = data.data;
                        }
                        else if (data != null && data.code == "A00007")
                        {
                            if (repeatget)
                            {
                                var repdata = Newtonsoft.Json.JsonConvert.DeserializeObject <BaseInfo <RepeatVideo> >(json);
                                if (repdata != null && repdata.data != null && repdata.data.fileIdBefore.Length == 32)
                                {
                                    return(GetAiQiYiURL(repdata.data.fileIdBefore, false));
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            return(Json(videoInfo, JsonRequestBehavior.AllowGet));
        }
Example #32
0
        public Task <BaseRestSharp.RestResponse> InvokeCall(HttpServiceRequest httpRequest, bool throwException = true,
                                                            bool isElasticLog = false, bool invokeAsync = false)
        {
            ServicePointManager.DefaultConnectionLimit = 200;
            // Base URL
            BaseRestSharp.RestClient    client   = new BaseRestSharp.RestClient(httpRequest.Url);
            BaseRestSharp.IRestResponse response = null;
            Stopwatch watch = new Stopwatch();


            // Method to be triggered
            BaseRestSharp.RestRequest request = new BaseRestSharp.RestRequest(httpRequest.Action, (BaseRestSharp.Method)httpRequest.MethodType)
            {
                Timeout = httpRequest.Timeout
            };

            if (httpRequest.CookieJar != null)
            {
                foreach (Cookie cookie in httpRequest.CookieJar)
                {
                    request.AddCookie(cookie.Name, cookie.Value);
                }
            }

            if (httpRequest.Body != null)
            {
                request.RequestFormat = BaseRestSharp.DataFormat.Json;
                request.AddJsonBody(httpRequest.Body);
            }

            if (httpRequest.Headers != null)
            {
                foreach (KeyValuePair <string, string> header in httpRequest.Headers.ToList())
                {
                    request.AddHeader(header.Key, header.Value);
                }
            }


            if (httpRequest.QueryStringParameters != null)
            {
                foreach (KeyValuePair <string, string> param in httpRequest.QueryStringParameters.ToList())
                {
                    request.AddQueryParameter(param.Key, param.Value);
                }
            }

            watch.Start();

            BaseRestSharp.RestResponse customRestResponse = null;
            TaskCompletionSource <BaseRestSharp.RestResponse> taskCompletionSource = new TaskCompletionSource <BaseRestSharp.RestResponse>();


            response = client.Execute(request);
            watch.Stop();

            taskCompletionSource.SetResult(customRestResponse);

            ResponseVerifications(response, throwException, httpRequest.Url, httpRequest.MethodType);


            return(taskCompletionSource.Task);
        }
Example #33
0
        private async Task<bool> SaveData()
        {
            List<DocLine> docs = new List<DocLine>();
            var ds = new DataSet();
            try
            {
                var t1 = new DataTable();
                DataRow row = null;
                t1.Columns.Add("DocNum");
                t1.Columns.Add("ItemBarcode");
                t1.Columns.Add("ScanAccQty");
                t1.Columns.Add("Balance");
                t1.Columns.Add("ScanRejQty");
                t1.Columns.Add("PalletNumber");
                t1.Columns.Add("GRV");
                docs = (await GoodsRecieveingApp.App.Database.GetSpecificDocsAsync(docCode)).Where(x => x.ItemQty == 0||x.GRN).ToList();
                if (docs.Count == 0)
                    return true;
                foreach (string str in docs.Select(x => x.ItemCode).Distinct())
                {
                    DocLine currentGRV = (await App.Database.GetSpecificDocsAsync(docCode)).Where(x =>x.GRN&& x.ItemCode == str).FirstOrDefault();
                    if (currentGRV != null&&await GRVmodule())
                    {
                        row = t1.NewRow();
                        row["DocNum"] = docCode;
                        row["ItemBarcode"] = (await GoodsRecieveingApp.App.Database.GetSpecificDocsAsync(docCode)).Where(x => x.ItemCode == str && x.ItemQty != 0).FirstOrDefault().ItemBarcode;
                        row["ScanAccQty"] = currentGRV.ScanAccQty;
                        row["Balance"] = 0;
                        row["ScanRejQty"] = currentGRV.ScanRejQty;
                        row["PalletNumber"] = 0;
                        row["GRV"] = true;
                        t1.Rows.Add(row);
                    }
                    else if (currentGRV!=null&&!await GRVmodule())
					{
                        await DisplayAlert("Please set up GRV in the settings","Error","OK");
					}
                    List<DocLine> CurrItems = (await App.Database.GetSpecificDocsAsync(docCode)).Where(x => !x.GRN && x.ItemCode == str&&x.ItemQty==0).ToList();
					if (CurrItems.Count()>0)
					{
                        row = t1.NewRow();
                        row["DocNum"] = docs.FirstOrDefault().DocNum;
                        row["ItemBarcode"] = (await GoodsRecieveingApp.App.Database.GetSpecificDocsAsync(docCode)).Where(x => x.ItemCode == str && x.ItemQty != 0).FirstOrDefault().ItemBarcode;
                        row["ScanAccQty"] = (await GoodsRecieveingApp.App.Database.GetSpecificDocsAsync(docCode)).Where(x => x.ItemCode == str && !x.GRN).Sum(x => x.ScanAccQty);
                        row["Balance"] = 0;
                        row["ScanRejQty"] = (await GoodsRecieveingApp.App.Database.GetSpecificDocsAsync(docCode)).Where(x => x.ItemCode == str && !x.GRN).Sum(x => x.ScanRejQty);
                        row["PalletNumber"] = 0;
                        row["GRV"] = false;
                        t1.Rows.Add(row);
                    }                 
                }
                ds.Tables.Add(t1);
            }
            catch (Exception)
            {
                return false;
            }
            string myds = Newtonsoft.Json.JsonConvert.SerializeObject(ds);           
                RestSharp.RestClient client = new RestSharp.RestClient();
                client.BaseUrl = new Uri(GoodsRecieveingApp.MainPage.APIPath);
                {
                    var Request = new RestSharp.RestRequest("SaveDocLine", RestSharp.Method.POST);
                    Request.RequestFormat = RestSharp.DataFormat.Json;
                    Request.AddJsonBody(myds);
                    var cancellationTokenSource = new CancellationTokenSource();
                    var res = await client.ExecuteAsync(Request, cancellationTokenSource.Token);
                    if (res.IsSuccessful && res.Content.Contains("COMPLETE"))
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }                  
        }
        public override async Task <HttpStatus[][]> SetTestResultToPerson(string token, SetResultRequest setResultRequest)
        {
            var request = new RestSharp.RestRequest($"api/sp_v0/sp_covid_form_lab_order_and_result_iu", RestSharp.Method.POST, RestSharp.DataFormat.Json);

            request.AddHeader("Authorization", $"Bearer {token}");
            //request.AddJsonBody(setResultRequest);
            //var body = Serialize(setResultRequest);
            //request.AddParameter("application/json", body, ParameterType.RequestBody);

            if (string.IsNullOrEmpty(setResultRequest.TestTitle))
            {
                if (!string.IsNullOrEmpty(settings?.Value?.TestTitle))
                {
                    setResultRequest.TestTitle = settings.Value?.TestTitle;
                }
            }
            if (string.IsNullOrEmpty(setResultRequest.TestLoinc))
            {
                if (!string.IsNullOrEmpty(settings?.Value?.TestLoinc))
                {
                    setResultRequest.TestLoinc = settings.Value?.TestLoinc;
                }
            }
            if (string.IsNullOrEmpty(setResultRequest.TestNclp))
            {
                if (!string.IsNullOrEmpty(settings?.Value?.TestNclp))
                {
                    setResultRequest.TestNclp = settings.Value?.TestNclp;
                }
            }
            if (string.IsNullOrEmpty(setResultRequest.SpecimenType))
            {
                if (!string.IsNullOrEmpty(settings?.Value?.SpecimenType))
                {
                    setResultRequest.SpecimenType = settings.Value?.SpecimenType;
                }
            }

            request.AddParameter("nUser_id", setResultRequest.UserId);
            request.AddParameter("nId", setResultRequest.Id);
            request.AddParameter("nCovid_form_data_id", setResultRequest.CovidFormDataId);
            request.AddParameter("nLaboratory_order_number", setResultRequest.nLaboratoryOrderNumber);
            request.AddParameter("vDiagnosis", setResultRequest.Diagnosis);
            request.AddParameter("vFinal_result", setResultRequest.FinalResult);
            request.AddParameter("vOrdered_by_physician_code", setResultRequest.OrderedByPhysicianCode);
            request.AddParameter("vOrdered_by_physician_name", setResultRequest.OrderedByPhysicianName);
            request.AddParameter("vOrdered_by_address", setResultRequest.OrderedByAddress);
            request.AddParameter("vOrdered_by_phone", setResultRequest.OrderedByPhone);
            request.AddParameter("vOrdered_by_email", setResultRequest.OrderedByEmail);
            request.AddParameter("dOrdered_at", setResultRequest.OrderedAt);
            request.AddParameter("vOrdered_by_care_provider_code", setResultRequest.OrderedByCareProviderCode);
            request.AddParameter("vOrdered_by_care_provider_name", setResultRequest.OrderedByCareProviderName);
            request.AddParameter("vOrdered_by_care_provider_speciality", setResultRequest.OrderedByCareProviderSpeciality);
            request.AddParameter("vSpecimen_id", setResultRequest.SpecimenId);
            request.AddParameter("vSpecimen_type", setResultRequest.SpecimenType);
            request.AddParameter("vRequired_screening", setResultRequest.RequiredScreening);
            request.AddParameter("dSpecimen_collected_at", setResultRequest.SpecimenCollectedAt);
            request.AddParameter("dSpecimen_sent_at", setResultRequest.SpecimenSentAt);
            request.AddParameter("dSpecimen_received_at", setResultRequest.SpecimenReceivedAt);
            request.AddParameter("vSpecimen_number", setResultRequest.SpecimenNumber);
            request.AddParameter("dScreening_ended_at", setResultRequest.ScreeningEndedAt);
            request.AddParameter("vTested_by_care_provider_name", setResultRequest.TestedByCareProviderName);
            request.AddParameter("nQuantity_to", setResultRequest.QuantityTo);
            request.AddParameter("vMicrobiology_screening_type", setResultRequest.MicrobiologyScreeningType);
            request.AddParameter("vScreening_final_result", setResultRequest.ScreeningFinalResult);
            request.AddParameter("vScreening_final_comment", setResultRequest.ScreeningFinalComment);
            request.AddParameter("vTest_nclp", setResultRequest.TestNclp);
            request.AddParameter("vTest_loinc", setResultRequest.TestLoinc);
            request.AddParameter("vTest_title", setResultRequest.TestTitle);
            request.AddParameter("nIs_rapid_test", setResultRequest.IsRapidTest);

            await Task.Delay(500);

            var response = await client.ExecuteAsync(request);

            logger.LogInformation($"eHealth: SetTestResultToPerson {setResultRequest.UserId}");
            if (!response.IsSuccessful)
            {
                throw new Exception(response.Content);
            }
            return(JsonConvert.DeserializeObject <Model.EZdravie.Payload.HttpStatus[][]>(response.Content, deserializeSettings));
        }
        public string[] GetCaptchaImage(ref string _status, bool usetwocap = false)
        {
            string[] sols = { "" };

            _status = "Getting Captcha...";
            //  mainForm.UpdateStatus();

            //load Steam page
            _client.BaseUrl = JoinUri;
            if (_formreq.proxy == true)
            {
                _client.Proxy = new WebProxy(_formreq.proxyval, _formreq.proxyport);
            }
            _request.Method = Method.GET;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
            var response = _client.Execute(_request);

            //Store captcha ID
            try
            {
                _captchaGid = CaptchaRegex.Matches(response.Content)[0].Groups[1].Value;
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());
                MessageBox.Show(response.Content);
                MessageBox.Show(response.ErrorException.ToString());
                MessageBox.Show(response.StatusCode.ToString());
            }
            //download and return captcha image
            _client.BaseUrl = new Uri(CaptchaUri + _captchaGid);
            if (_formreq.proxy == true)
            {
                _client.Proxy = new WebProxy(_formreq.proxyval, _formreq.proxyport);
            }

            string finalpayload = "";

            for (int i = 0; i < 1; i++)
            {
                _status = "Getting Captcha.. " + (i / 10) * 100 + "%";
                // mainForm.UpdateStatus(_index, _status);

                var    captchaResponse = _client.DownloadData(_request);
                string cap1            = getbasefromimage(captchaResponse);

                finalpayload = cap1;
            }
            _status = "Recognizing Captcha!";
            if (usetwocap)
            {
                _client.BaseUrl = new Uri("http://2captcha.com");
                var srequest = new RestSharp.RestRequest("in.php", RestSharp.Method.POST);
                srequest.AddParameter("key", MainForm.twocapkey);
                srequest.AddParameter("body", "data:image/jpg;base64," + finalpayload);
                srequest.AddParameter("method", "base64");
                srequest.AddParameter("soft_id", "2370");
                srequest.AddParameter("json", "0");

                var responsecapx = _client.Execute(srequest);
                var respp        = responsecapx.Content.Split(new string[] { "|" }, StringSplitOptions.None);
                if (respp[0] != "OK")
                {
                    MessageBox.Show(responsecapx.Content);
                    return(sols);
                }
                else
                {
                    try
                    {
                        var id = respp[1];
                        srequest.Parameters.Clear();
                        Thread.Sleep(10000);
                        _client.BaseUrl = new Uri("http://2captcha.com");
                        srequest        = new RestSharp.RestRequest("res.php", RestSharp.Method.POST);
                        srequest.AddParameter("key", MainForm.twocapkey);
                        srequest.AddParameter("action", "get");
                        srequest.AddParameter("id", id);
                        srequest.AddParameter("soft_id", "2370");
                        srequest.AddParameter("json", "0");
                        responsecapx = _client.Execute(srequest);
                        respp        = responsecapx.Content.Split(new string[] { "|" }, StringSplitOptions.None);
                        if (respp[0] != "OK")
                        {
                            Thread.Sleep(6000);
                            _client.BaseUrl = new Uri("http://2captcha.com");
                            srequest        = new RestSharp.RestRequest("res.php", RestSharp.Method.POST);
                            srequest.AddParameter("key", MainForm.twocapkey);
                            srequest.AddParameter("action", "get");
                            srequest.AddParameter("id", id);
                            srequest.AddParameter("soft_id", "2370");
                            srequest.AddParameter("json", "0");
                            responsecapx = _client.Execute(srequest);
                            respp        = responsecapx.Content.Split(new string[] { "|" }, StringSplitOptions.None);
                            if (respp[0] != "OK")
                            {
                                return(sols);
                            }
                            else
                            {
                                sols[0] = respp[1];
                                return(sols);
                            }
                        }
                        else
                        {
                            sols[0] = respp[1];
                            return(sols);
                        }
                    }
                    catch (Exception)
                    {
                        return(sols);
                    }
                }
            }
            else
            {
                _client.BaseUrl = new Uri("http://api.captchasolutions.com/");
                var request = new RestSharp.RestRequest("solve", RestSharp.Method.POST);
                request.AddParameter("p", "base64");
                request.AddParameter("captcha", "data:image/jpg;base64," + finalpayload);
                request.AddParameter("key", MainForm.apixkey);
                request.AddParameter("secret", MainForm.secxkey);
                request.AddParameter("out", "txt");


                var    responsecap = _client.Execute(request);
                string replacement = Regex.Replace(responsecap.Content, @"\t|\n|\r", "");
                if (responsecap.Content == "\n\t\t\t\t\t\t<captchasolutions>\n\t\t\t\t\t\t\t<decaptcha>\n\t\t\t\t\t\t\t\tError: You have 0 balance left in your account.\n\t\t\t\t\t\t\t</decaptcha>\n\t\t\t\t\t\t</captchasolutions>\n\t\t\t\t\t\n\t\n\n\n")
                {
                    MessageBox.Show(responsecap.Content);
                    return(sols);
                }
                sols[0] = replacement;
                return(sols);
            }
        }
Example #36
0
 /// <summary>
 /// More information about filtering: http://doc.prestashop.com/display/PS14/Chapter+8+-+Advanced+Use
 /// </summary>
 /// <param name="Filter">Example: key:name value:Apple</param>
 /// <param name="Sort">Field_ASC or Field_DESC. Example: name_ASC or name_DESC</param>
 /// <param name="Limit">Example: 5 limit to 5. 9,5 Only include the first 5 elements starting from the 10th element.</param>
 /// <returns></returns>
 public List <Entities.warehouse> GetByFilter(Dictionary <string, string> Filter, string Sort, string Limit)
 {
     RestSharp.RestRequest request = this.RequestForFilter("warehouses", "full", Filter, Sort, Limit, "warehouses");
     return(this.ExecuteForFilter <List <Entities.warehouse> >(request));
 }
Example #37
0
        private async Task SendPushAndroidAsync(AndroidNotification androidNotification, Notification notification, AndroidToken androidToken, object data, AndroidTokenRepository androidTokenRepository)
        {
            dynamic model = new ExpandoObject();

            if (data != null)
            {
                model           = data;
                model.UserId    = androidToken.UserId;
                model.CompanyId = androidToken.CompanyId;
            }
            //Analisar necessidade de setar a messagem em mais atributos
            //string alert;
            string body  = notification.Message;
            string title = notification.Title;
            string to    = androidNotification.TokenId;
            //int badge = 1;
            //string sound = "default";
            //string vibrate = "true";

            // Get the server key from FCM console
            var serverKey = string.Format("key={0}", Config.GetEnvironmentVariable("Firebase_ServerKey"));

            // Get the sender id from FCM console
            var senderId = string.Format("id={0}", Config.GetEnvironmentVariable("Firebase_SenderId"));

            object payLoad;

            if (data is null)
            {
                payLoad = new
                {
                    to,
                    notification = new
                    {
                        title,
                        body
                    }
                };
            }
            else
            {
                payLoad = new
                {
                    to,
                    notification = new
                    {
                        title,
                        body
                    },
                    data = new
                    {
                        model
                    }
                };
            }

            var           client  = new RestClient("https://fcm.googleapis.com/fcm/send");
            var           request = new RestSharp.RestRequest(Method.POST);
            IRestResponse response;

            request.JsonSerializer = new NewtonsoftJsonSerializer();
            request.RequestFormat  = DataFormat.Json;
            request.AddHeader("Authorization", serverKey);
            request.AddHeader("Sender", senderId);
            request.AddHeader("Content-Type", "application/json");
            request.AddJsonBody(payLoad);
            response = client.Execute(request);

            try
            {
                FcmResponse resposta = new FcmResponse();

                resposta = JsonConvert.DeserializeObject <FcmResponse>(response.Content);

                if (resposta.Results != null && resposta.Results.Count() > 0)
                {
                    androidNotification.Message_Id = resposta.Results.FirstOrDefault().Message_id;
                }
                androidNotification.Multicast_Id = resposta.Multicast_id;
                androidNotification.Success      = resposta.Success;

                if (androidNotification.Success == 0)
                {
                    try
                    {
                        androidToken.DeletedAt = DateTime.UtcNow;
                        await androidTokenRepository.UpdateNotification(androidToken);
                    }
                    catch { }
                }
            }
            catch (Exception)
            {
                androidToken.DeletedAt = DateTime.UtcNow;
                await androidTokenRepository.UpdateNotification(androidToken);
            }
        }
Example #38
0
        public Result Post(Post post, Func <IRestResponse, Result> handler)
        {
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11;


            Result result = new Result();

            var content  = post.Parameters.Count == 0 ? Model.ReadEmbedXML(post.ConfigName) : "";
            var postData = post.Parameters.Count == 0 ? Model.CreatePosXML(post.Request, content).Trim() : "";


            if (!post.Request.Is3D)
            {
                RestSharp.RestClient  client  = new RestSharp.RestClient(post.Request.Url);
                RestSharp.RestRequest request = new RestSharp.RestRequest(post.Method);

                if (post.Request.Accounts.ContainsKey("Method"))
                {
                    request.Resource = post.Request.Accounts["Method"].ToString();
                }

                request.RequestFormat = post.RequestFormat;

                if (!post.IsQueryParameter)
                {
                    request.AddParameter(post.ContentType, post.PreTag + postData, RestSharp.ParameterType.RequestBody);
                }
                else
                {
                    if (post.Parameters.Count == 0)
                    {
                        request.AddParameter(post.PreTag, postData);
                    }
                    else
                    {
                        request.Resource = post.ContentType;

                        foreach (var item in post.Parameters)
                        {
                            request.AddParameter(item.Key, item.Value, ParameterType.UrlSegment);
                        }
                    }
                }


                client.Timeout = Convert.ToInt32(20000);

                var serverResponse = client.Execute(request);

                if (serverResponse.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    result = handler(serverResponse);
                }
                else
                {
                    result                = new Result();
                    result.Status         = false;
                    result.Error          = "[TIMEOUT]";
                    result.RequestContent = serverResponse.Content;
                }
            }
            else
            {
                result.Status        = true;
                result.ResultContent = postData;
            }

            result.RequestData = post.Request;

            return(result);
        }
        private async void TxfBarcode_TextChanged(object sender, TextChangedEventArgs e)
        {
            if (txfBarcode.Text != "")
            {
                Loader.IsVisible = true;
                try
                {
                    BOMItem bi = await GoodsRecieveingApp.App.Database.GetBOMItem(txfBarcode.Text);

                    Loader.IsVisible = false;
                    Vibration.Vibrate();
                    message.DisplayMessage("You can only add single items", true);
                }
                catch
                {
                    try
                    {
                        RestSharp.RestClient client = new RestSharp.RestClient();
                        string path = "FindDescAndCode";
                        client.BaseUrl = new Uri(GoodsRecieveingApp.MainPage.APIPath + path);
                        {
                            string str     = $"GET?qrystr=ACCPRD|4|" + txfBarcode.Text;
                            var    Request = new RestSharp.RestRequest();
                            Request.Resource = str;
                            Request.Method   = RestSharp.Method.GET;
                            var cancellationTokenSource = new CancellationTokenSource();
                            var res = await client.ExecuteAsync(Request, cancellationTokenSource.Token);

                            if (res.IsSuccessful && res.Content.Split('|')[0].Contains("0"))
                            {
                                if (res.Content.Split('|')[2] == MainPage.docLines.Find(x => x.ItemDesc == "1ItemFromMain").ItemCode)
                                {
                                    lblItemDesc.Text = res.Content.Split('|')[3];
                                    ItemBarcode      = res.Content.Split('|')[4];
                                    ItemCode         = res.Content.Split('|')[2];
                                    Loader.IsVisible = false;
                                }
                                else
                                {
                                    Loader.IsVisible = false;
                                    Vibration.Vibrate();
                                    message.DisplayMessage("This is not the same product", true);
                                    txfBarcode.Text = "";
                                    txfBarcode.Focus();
                                    return;
                                }
                            }
                        }
                    }
                    catch
                    {
                        lblItemDesc.Text = "No Item With This Code";
                        Loader.IsVisible = false;
                        Vibration.Vibrate();
                        message.DisplayMessage("We could not find this item code", true);
                        txfBarcode.Text = "";
                        txfBarcode.Focus();
                        return;
                    }
                }
                txfQTY.Focus();
            }
        }
Example #40
0
 private void AddAuthHeader(ref RestRequest request, string authToken)
 {
     request.AddHeader("X-Plex-Token", authToken);
     AddHeaders(ref request);
 }
Example #41
0
        /// <summary>
        /// Send raw HTTP request to the server and request the map tiles around the coords. This mimics browser on the map page.
        /// </summary>
        public static List <MapTile> GetMapTiles(Account acc, Coordinates coords)
        {
            switch (acc.AccInfo.ServerVersion)
            {
            case Classificator.ServerVersionEnum.T4_4:
                var ajaxToken = DriverHelper.GetJsObj <string>(acc, "ajaxToken");

                var req = new RestSharp.RestRequest
                {
                    Resource = "/ajax.php?cmd=mapPositionData",
                    Method   = Method.POST,
                };

                req.AddParameter("cmd", "mapPositionData");
                req.AddParameter("data[x]", coords.x.ToString());
                req.AddParameter("data[y]", coords.y.ToString());
                req.AddParameter("data[zoomLevel]", "3");
                req.AddParameter("ajaxToken", ajaxToken);

                var resString = HttpHelper.SendPostReq(acc, req);

                var root = JsonConvert.DeserializeObject <MapPositionDataT4_4.Root>(resString);
                if (root.response.error)
                {
                    throw new Exception("Unable to get T4.4 map position data!\n" + root.response.error);
                }
                return(root.response.data.tiles.Select(x => x.GetMapTile()).ToList());

            //case Classificator.ServerVersionEnum.T4_5:
            //{
            //    var bearerToken = DriverHelper.GetBearerToken(acc);

            //    var reqMapInfo = new RestSharp.RestRequest
            //    {
            //        Resource = "/api/v1/ajax/mapInfo",
            //        Method = Method.POST,
            //        RequestFormat = DataFormat.Json
            //    };
            //    reqMapInfo.AddHeader("authorization", $"Bearer {bearerToken}");
            //    reqMapInfo.AddHeader("content-type", "application/json; charset=UTF-8");
            //    reqMapInfo.AddJsonBody(GenerateMapInfo(coords));

            //    var mapInfoRes = HttpHelper.SendPostReq(acc, reqMapInfo);

            //    var mapPosition = new SendMapPositionT4_5.Root()
            //    {
            //        data = new SendMapPositionT4_5.Data()
            //        {
            //            x = coords.x,
            //            y = coords.y,
            //            zoomLevel = 3,
            //            ignorePositions = new List<object>()
            //        }
            //    };

            //    var reqMapPosition = new RestSharp.RestRequest
            //    {
            //        Resource = "/api/v1/ajax/mapPositionData",
            //        Method = Method.POST,
            //        RequestFormat = DataFormat.Json
            //    };
            //    reqMapPosition.AddHeader("authorization", $"Bearer {bearerToken}");
            //    reqMapPosition.AddHeader("content-type", "application/json; charset=UTF-8");
            //    reqMapPosition.AddJsonBody(mapPosition);

            //    var mapPositionRes = HttpHelper.SendPostReq(acc, reqMapPosition);
            //    var mapPositionData = JsonConvert.DeserializeObject<MapPositionDataT4_5>(mapPositionRes);
            //    return mapPositionData.tiles.Select(x => x.GetMapTile()).ToList();
            //}
            default:
            {
                var bearerToken = DriverHelper.GetBearerToken(acc);

                var reqMapInfo = new RestSharp.RestRequest
                {
                    Resource      = "/api/v1/map/info",
                    Method        = Method.POST,
                    RequestFormat = DataFormat.Json
                };
                reqMapInfo.AddHeader("authorization", $"Bearer {bearerToken}");
                reqMapInfo.AddHeader("content-type", "application/json; charset=UTF-8");
                reqMapInfo.AddJsonBody(GenerateMapInfo(coords));

                var mapInfoRes = HttpHelper.SendPostReq(acc, reqMapInfo);

                var mapPosition = new SendMapPositionT4_5.Root()
                {
                    data = new SendMapPositionT4_5.Data()
                    {
                        x               = coords.x,
                        y               = coords.y,
                        zoomLevel       = 3,
                        ignorePositions = new List <object>()
                    }
                };

                var reqMapPosition = new RestSharp.RestRequest
                {
                    Resource      = "/api/v1/map/position",
                    Method        = Method.POST,
                    RequestFormat = DataFormat.Json
                };
                reqMapPosition.AddHeader("authorization", $"Bearer {bearerToken}");
                reqMapPosition.AddHeader("content-type", "application/json; charset=UTF-8");
                reqMapPosition.AddJsonBody(mapPosition);

                var mapPositionRes  = HttpHelper.SendPostReq(acc, reqMapPosition);
                var mapPositionData = JsonConvert.DeserializeObject <MapPositionDataT4_5>(mapPositionRes);
                return(mapPositionData.tiles.Select(x => x.GetMapTile()).ToList());
            }
            }
        }
Example #42
0
 private void Setup(ref RestRequest request)
 {
     request.JsonSerializer = new NewtonsoftJsonSerializer(Settings);
 }
Example #43
0
 public RegisterRepo()
 {
     _client = new RestClient(BaseUrl);
     request = new RestRequest("api/register", Method.POST);
 }
Example #44
0
        private static IRestResponse <T> ExectueRequest <T>(Method method, RestClient client, RestRequest request)
            where T : new()
        {
            IRestResponse <T> result;

            client.FollowRedirects = false;
            result = client.Execute <T>(request);
            if (result.StatusCode == HttpStatusCode.Redirect)
            {
                var redirectUrl = GetRedirectUrl(result);
                request = new RestRequest(redirectUrl, method);
                result  = client.Execute <T>(request);
            }
            return(result);
        }
Example #45
0
        static void Main(string[] args)
        {
            try
            {
                string apiUrlKey = "apiUrl";
                string input;
                var    random     = new Randomizer();
                var    randomDate = new Bogus.DataSets.Date();

                var apiUrl     = ConfigurationManager.AppSettings[apiUrlKey];
                var restClient = new RestClient(apiUrl);

                Console.WriteLine("Press ENTER without specifying value to exit...\n\n");
                Console.WriteLine("How many request models you want to send? Type in number: ");

                while (!string.IsNullOrEmpty(input = Console.ReadLine()))
                {
                    var result = 0;
                    var parsed = int.TryParse(input, out result);

                    if (!parsed)
                    {
                        Console.WriteLine("Value you've entered is not valid INT");
                    }
                    else
                    {
                        for (var i = 0; i < result; i++)
                        {
                            Console.WriteLine($"Sending request no. {i}...");

                            var request = new RestSharp.RestRequest("data", Method.POST);
                            request.JsonSerializer = new NewtonsoftJsonSerializer();

                            request.AddJsonBody(new RequestModel[] { new RequestModel
                                                                     {
                                                                         Index  = random.Int(0, int.MaxValue),
                                                                         Date   = randomDate.Future(),
                                                                         Name   = random.String2(20),
                                                                         Visits = random.Int(0, int.MaxValue),
                                                                     } });

                            var response = restClient.Execute(request);

                            if (response.StatusCode == System.Net.HttpStatusCode.Created)
                            {
                                Console.WriteLine($"Request no. {i} sent succesfully.");
                            }
                            else
                            {
                                throw new Exception($"Got status code <{response.StatusCode}> instead of <{System.Net.HttpStatusCode.Created}>.");
                            }
                        }

                        Console.WriteLine("Finished sending requests to API!");
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine($"Exception occured: {e}");
                Console.WriteLine("Press any key to exit...");
                Console.ReadKey();
            }
        }
Example #46
0
        public async Task <ResponseData> LayChiTietPhieuNhapKho(int phieuNhapId)
        {
            try
            {
                string url     = string.Format("{0}/api/import/get-detail/{1}", Config.HOST, phieuNhapId);
                var    client  = new RestSharp.RestClient(url);
                var    request = new RestSharp.RestRequest(Method.GET);
                request.AddHeader("content-type", "application/json; charset=utf-8");
                request.AddHeader("x-access-token", UserResponse.AccessToken);

                var response = await client.ExecuteTaskAsync(request);

                var responseParse = Newtonsoft.Json.JsonConvert.DeserializeObject <dynamic>(response.Content);
                if (response.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    var     data    = responseParse["data"];
                    NhapKho nhapKho = Newtonsoft.Json.JsonConvert.DeserializeObject <NhapKho>(data.ToString());
                    Kho     kho     = new Kho()
                    {
                        Id  = data["IdKho"],
                        Ten = data["TenKho"]
                    };
                    NhanVien nhanVien = new NhanVien()
                    {
                        Id  = data["IdNhanVien"],
                        Ten = data["TenNhanVien"]
                    };
                    NhaCungCap nhaCungCap = new NhaCungCap()
                    {
                        Id  = data["IdNhaCungCap"],
                        Ten = data["TenNhaCungCap"]
                    };
                    nhapKho.NhanVien   = nhanVien;
                    nhapKho.Kho        = kho;
                    nhapKho.NhaCungCap = nhaCungCap;

                    var danhSachVatTuJson = Newtonsoft.Json.JsonConvert.DeserializeObject <dynamic>(data["DanhSachVatTu"].ToString());

                    List <ChiTietNhapKho> listChiTietNhapKho = new List <ChiTietNhapKho>();
                    foreach (var item in danhSachVatTuJson)
                    {
                        ChiTietNhapKho chiTiet = Newtonsoft.Json.JsonConvert.DeserializeObject <ChiTietNhapKho>(item.ToString());
                        VatTu          vatTu   = new VatTu()
                        {
                            Id  = item["IdVatTu"],
                            Ten = item["TenVatTu"]
                        };
                        chiTiet.VatTu   = vatTu;
                        chiTiet.NhapKho = nhapKho;
                        listChiTietNhapKho.Add(chiTiet);
                    }
                    return(new ResponseData()
                    {
                        Status = Config.CODE_OK,
                        Data = listChiTietNhapKho,
                        Message = ""
                    });
                }
                else
                {
                    return(Util.GenerateErrorResponse(response, responseParse));
                }
            }
            catch (Exception ex)
            {
                return(null);
            }
        }
        public override async Task <HttpStatus[][]> RegisterPerson(string token, RegisterPersonRequest registerPersonRequest)
        {
            var request = new RestSharp.RestRequest($"api/sp_v0/sp_covid_form_cc_iu", RestSharp.Method.POST, RestSharp.DataFormat.Json);

            request.AddHeader("Authorization", $"Bearer {token}");
            //request.AddJsonBody(setResultRequest);
            //var body = Serialize(setResultRequest);
            //request.AddParameter("application/json", body, ParameterType.RequestBody);
            request.AddParameter("nUser_id", registerPersonRequest.nUser_id);
            request.AddParameter("vPass", registerPersonRequest.vPass);
            request.AddParameter("vState", registerPersonRequest.vState);
            request.AddParameter("nTriage", registerPersonRequest.nTriage);
            request.AddParameter("vFirst_name", registerPersonRequest.vFirst_name);
            request.AddParameter("vLast_name", registerPersonRequest.vLast_name);
            request.AddParameter("vBirth_number", registerPersonRequest.vBirth_number);
            request.AddParameter("vNationality", registerPersonRequest.vNationality);
            request.AddParameter("vPatient_localization", registerPersonRequest.vPatient_localization);
            request.AddParameter("vEmail", registerPersonRequest.vEmail);
            request.AddParameter("vPhone_number", registerPersonRequest.vPhone_number);
            request.AddParameter("vEmail_secondary", registerPersonRequest.vEmail_secondary);
            request.AddParameter("vPhone_number_secondary", registerPersonRequest.vPhone_number_secondary);
            request.AddParameter("vMunicipality", registerPersonRequest.vMunicipality);
            request.AddParameter("vStreet", registerPersonRequest.vStreet);
            request.AddParameter("vStreet_number", registerPersonRequest.vStreet_number);
            request.AddParameter("vPostal_code", registerPersonRequest.vPostal_code);
            request.AddParameter("vCountry", registerPersonRequest.vCountry);
            request.AddParameter("vAddress_note", registerPersonRequest.vAddress_note);
            request.AddParameter("vTemporary_municipality", registerPersonRequest.vTemporary_municipality);
            request.AddParameter("vTemporary_street", registerPersonRequest.vTemporary_street);
            request.AddParameter("vTemporary_street_number", registerPersonRequest.vTemporary_street_number);
            request.AddParameter("vTemporary_postal_code", registerPersonRequest.vTemporary_postal_code);
            request.AddParameter("vTemporary_country", registerPersonRequest.vTemporary_country);
            request.AddParameter("vTemporary_address_note", registerPersonRequest.vTemporary_address_note);
            request.AddParameter("nHas_high_temperature", registerPersonRequest.nHas_high_temperature);
            request.AddParameter("nHas_continuous_cough", registerPersonRequest.nHas_continuous_cough);
            request.AddParameter("nHas_fatigue", registerPersonRequest.nHas_fatigue);
            request.AddParameter("nHas_head_aches", registerPersonRequest.nHas_head_aches);
            request.AddParameter("nHas_hinge_ache", registerPersonRequest.nHas_hinge_ache);
            request.AddParameter("nHas_cold", registerPersonRequest.nHas_cold);
            request.AddParameter("nHas_thrown_up", registerPersonRequest.nHas_thrown_up);
            request.AddParameter("nHas_heart_palpitation", registerPersonRequest.nHas_heart_palpitation);
            request.AddParameter("nHas_diarrhea", registerPersonRequest.nHas_diarrhea);
            request.AddParameter("nHas_ague", registerPersonRequest.nHas_ague);
            request.AddParameter("nHas_mucus_cough", registerPersonRequest.nHas_mucus_cough);
            request.AddParameter("nHas_dyspnoea", registerPersonRequest.nHas_dyspnoea);
            request.AddParameter("nHas_come_from_abroad", registerPersonRequest.nHas_come_from_abroad);
            request.AddParameter("nHas_influenza_vaccination", registerPersonRequest.nHas_influenza_vaccination);
            request.AddParameter("nHas_clinical_symptoms", registerPersonRequest.nHas_clinical_symptoms);
            request.AddParameter("vInfluenza_vaccine_name", registerPersonRequest.vInfluenza_vaccine_name);
            request.AddParameter("dInfluenza_vaccine_date", registerPersonRequest.dInfluenza_vaccine_date);
            request.AddParameter("vOther_symptoms", registerPersonRequest.vOther_symptoms);
            request.AddParameter("dInfection_start", registerPersonRequest.dInfection_start);
            request.AddParameter("vDrugs_used", registerPersonRequest.vDrugs_used);
            request.AddParameter("vSimilar_disease_occurence", registerPersonRequest.vSimilar_disease_occurence);
            request.AddParameter("vTravel_history", registerPersonRequest.vTravel_history);
            request.AddParameter("nPersons_count_at_home", registerPersonRequest.nPersons_count_at_home);
            request.AddParameter("nHome_rooms_number", registerPersonRequest.nHome_rooms_number);
            request.AddParameter("nContagion_concern_reasons", registerPersonRequest.nContagion_concern_reasons);
            request.AddParameter("vQuarantine_reason", registerPersonRequest.vQuarantine_reason);
            request.AddParameter("dQuarantine_start", registerPersonRequest.dQuarantine_start);
            request.AddParameter("dQuarantine_end", registerPersonRequest.dQuarantine_end);
            request.AddParameter("vQuarantine_country", registerPersonRequest.vQuarantine_country);
            request.AddParameter("vQuarantine_address_note", registerPersonRequest.vQuarantine_address_note);
            request.AddParameter("vHealth_insurance_company", registerPersonRequest.vHealth_insurance_company);
            request.AddParameter("nLongitude", registerPersonRequest.nLongitude);
            request.AddParameter("nLatitude", registerPersonRequest.nLatitude);
            request.AddParameter("nShare_my_location", registerPersonRequest.nShare_my_location);
            request.AddParameter("nSend_data_to_my_gp", registerPersonRequest.nSend_data_to_my_gp);
            request.AddParameter("vGp_name", registerPersonRequest.vGp_name);
            request.AddParameter("vGp_email", registerPersonRequest.vGp_email);
            request.AddParameter("vCar_plate_number", registerPersonRequest.vCar_plate_number);
            request.AddParameter("nDesignated_drivein_id", registerPersonRequest.nDesignated_drivein_id);
            request.AddParameter("vDesignated_drivein_city", registerPersonRequest.vDesignated_drivein_city);
            request.AddParameter("vDesignated_drivein_street_name", registerPersonRequest.vDesignated_drivein_street_name);
            request.AddParameter("vDesignated_drivein_street_number", registerPersonRequest.vDesignated_drivein_street_number);
            request.AddParameter("vDesignated_drivein_zip_code", registerPersonRequest.vDesignated_drivein_zip_code);
            request.AddParameter("nDesignated_drivein_longitude", registerPersonRequest.nDesignated_drivein_longitude);
            request.AddParameter("nDesignated_drivein_latitude", registerPersonRequest.nDesignated_drivein_latitude);
            request.AddParameter("dDesignated_drivein_scheduled_at", registerPersonRequest.dDesignated_drivein_scheduled_at);
            request.AddParameter("dDrivein_entered_at", registerPersonRequest.dDrivein_entered_at);
            request.AddParameter("dDrivein_left_at", registerPersonRequest.dDrivein_left_at);
            request.AddParameter("nAssesor_person_id", registerPersonRequest.nAssesor_person_id);
            request.AddParameter("dOperator_assessed_at", registerPersonRequest.dOperator_assessed_at);
            request.AddParameter("dMedical_assessed_at", registerPersonRequest.dMedical_assessed_at);
            request.AddParameter("nIs_smoking", registerPersonRequest.nIs_smoking);
            request.AddParameter("dFever_started_at", registerPersonRequest.dFever_started_at);
            request.AddParameter("dFever_ended_at", registerPersonRequest.dFever_ended_at);
            request.AddParameter("nHas_lost_sense_of_smell", registerPersonRequest.nHas_lost_sense_of_smell);
            request.AddParameter("nHas_lost_sense_of_taste", registerPersonRequest.nHas_lost_sense_of_taste);
            request.AddParameter("nHas_pneumonia", registerPersonRequest.nHas_pneumonia);
            request.AddParameter("nHas_hypertension", registerPersonRequest.nHas_hypertension);
            request.AddParameter("nHas_cardiovascular_disease", registerPersonRequest.nHas_cardiovascular_disease);
            request.AddParameter("nHas_diabetes", registerPersonRequest.nHas_diabetes);
            request.AddParameter("nHas_oncological_disease", registerPersonRequest.nHas_oncological_disease);
            request.AddParameter("vPerson_identification_number", registerPersonRequest.vPerson_identification_number);
            request.AddParameter("nHas_severe_health_disability", registerPersonRequest.nHas_severe_health_disability);
            request.AddParameter("vHealth_disability_id_card", registerPersonRequest.vHealth_disability_id_card);
            request.AddParameter("nHas_disability_pension", registerPersonRequest.nHas_disability_pension);
            request.AddParameter("vIce_first_name", registerPersonRequest.vIce_first_name);
            request.AddParameter("vIce_last_name", registerPersonRequest.vIce_last_name);
            request.AddParameter("vIce_email", registerPersonRequest.vIce_email);
            request.AddParameter("vIce_phone", registerPersonRequest.vIce_phone);
            request.AddParameter("vEntered_by_first_name", registerPersonRequest.vEntered_by_first_name);
            request.AddParameter("vEntered_by_last_name", registerPersonRequest.vEntered_by_last_name);
            request.AddParameter("vEntered_by_email", registerPersonRequest.vEntered_by_email);
            request.AddParameter("vEntered_by_phone", registerPersonRequest.vEntered_by_phone);
            request.AddParameter("nQuarantine_center_id", registerPersonRequest.nQuarantine_center_id);
            request.AddParameter("dBirth_date", registerPersonRequest.dBirth_date);
            request.AddParameter("vGender", registerPersonRequest.vGender);
            request.AddParameter("nHas_planned_operation", registerPersonRequest.nHas_planned_operation);
            request.AddParameter("dOperation_planned_at", registerPersonRequest.dOperation_planned_at);
            request.AddParameter("nOperation_planned_in_subject_id", registerPersonRequest.nOperation_planned_in_subject_id);
            request.AddParameter("vOperation_planned_in_name", registerPersonRequest.vOperation_planned_in_name);
            request.AddParameter("vHas_come_from_country", registerPersonRequest.vHas_come_from_country);
            request.AddParameter("dEntry_from_abroad_planned_at", registerPersonRequest.dEntry_from_abroad_planned_at);
            request.AddParameter("vPersonal_id", registerPersonRequest.vPersonal_id);
            request.AddParameter("vQuarantine_municipality", registerPersonRequest.vQuarantine_municipality);
            request.AddParameter("vQuarantine_street", registerPersonRequest.vQuarantine_street);
            request.AddParameter("vQuarantine_street_number", registerPersonRequest.vQuarantine_street_number);
            request.AddParameter("vQuarantine_postal_code", registerPersonRequest.vQuarantine_postal_code);
            request.AddParameter("nHas_been_exposed", registerPersonRequest.nHas_been_exposed);
            request.AddParameter("nIs_mom_user", registerPersonRequest.nIs_mom_user);

            await Task.Delay(500);

            logger.LogInformation($"eHealth: Register person {registerPersonRequest.vBirth_number.GetSHA256Hash()}");
            var response = await client.ExecuteAsync(request);

            if (!response.IsSuccessful)
            {
                throw new Exception(response.Content);
            }
            return(JsonConvert.DeserializeObject <Model.EZdravie.Payload.HttpStatus[][]>(response.Content, deserializeSettings));
        }
Example #48
0
        /// <summary>
        /// Основной конструктор.
        /// </summary>
        protected RequestBase()
        {
            InitQueryParametersCashe();

            _request = new RestSharp.RestRequest();
        }
Example #49
0
        public string CreateProduct(string access_token, string product_name, string product_discription, double product_price, double product_shipping, string product_sku)
        {
            // access_token string Required. Provided in Oauth flow.
            // product_name string Required. Product name should be unique.
            // product_price numeric / float Required. A numeric / float value that represents the price of the product.
            // product_shipping numeric / float A numeric / float value that represents how much the cost if the product would be shipped to the buyer.
            // product_sku string Merchant's sku for the product.

            this.access_token        = access_token;
            this.product_name        = product_name;
            this.product_price       = product_price;
            this.product_shipping    = product_shipping;
            this.product_sku         = product_sku;
            this.product_description = product_discription;
            try
            {
                string url    = "https://api.aligncommerce.com/products";
                var    client = new RestSharp.RestClient();
                client.BaseUrl       = url;
                client.Authenticator = new HttpBasicAuthenticator(user, pass);
                var request = new RestSharp.RestRequest();
                request.Method = Method.POST;
                //  request.Resource = json;
                request.AddParameter("access_token", this.access_token);
                request.AddParameter("product_name", this.product_name);
                request.AddParameter("product_price", this.product_price);
                request.AddParameter("product_shipping", this.product_shipping);
                request.AddParameter("product_sku", this.product_sku);
                request.AddParameter("product_description", this.product_description);
                IRestResponse response = client.Execute(request);
                //  return response.Content.ToString();

                if (response.StatusCode.ToString() == "200")
                {
                    var js  = new JavaScriptSerializer();
                    var dic = js.Deserialize <Dictionary <string, string> >(response.Content);
                    this.Message = dic["message"];
                    return(Message);
                }

                else if (response.StatusCode.ToString() == "400" ||
                         response.StatusCode.ToString() == "401" ||
                         response.StatusCode.ToString() == "402" ||
                         response.StatusCode.ToString() == "403" ||
                         response.StatusCode.ToString() == "404" ||
                         response.StatusCode.ToString() == "500" ||
                         response.StatusCode.ToString() == "502")
                {
                    var js  = new JavaScriptSerializer();
                    var dic = js.Deserialize <Dictionary <string, string> >(response.Content);
                    this.Message = dic["error_message"];
                    return(Message);
                }

                else
                {
                    return(response.Content);
                }
            }
            catch (Exception e)
            {
                return(e.ToString());
            }
        }
        private async void txfNumberOfItem_Completed(object sender, EventArgs e)
        {
            if (txfNumberOfItem.Text.Length > 0)
            {
                try
                {
                    int i = Convert.ToInt32(txfNumberOfItem.Text);
                    if (!await CheckExists(i + ""))
                    {
                        PackCode = "F";
                        if (i > 9)
                        {
                            PackCode += txfNumberOfItem.Text;
                        }
                        else
                        {
                            PackCode += "0" + txfNumberOfItem.Text;
                        }
                        PackCode += "" + MainPage.docLines.First().ItemBarcode.Substring(7, 5);
                    }
                    try
                    {
                        BOMItem boi = await GoodsRecieveingApp.App.Database.GetBOMItem(PackCode);

                        if (PackCode != null)
                        {
                            // sending pack code to print queue
                            RestClient client = new RestClient();
                            string     path   = "DocumentSQLConnection";
                            client.BaseUrl = new Uri(GoodsRecieveingApp.MainPage.APIPath + path);
                            {
                                string str                 = $"POST?qry=INSERT INTO tblPrintQue (Barcode,Qty)VALUES('" + PackCode + "',1)";
                                var    Request             = new RestSharp.RestRequest(str, Method.POST);
                                CancellationTokenSource ct = new CancellationTokenSource();
                                var res = await client.ExecuteAsync(Request, ct.Token);

                                if (!res.IsSuccessful)
                                {
                                    Vibration.Vibrate();
                                    message.DisplayMessage("Could not send codes to printing", false);
                                }
                            }
                        }
                        message.DisplayMessage("Complete!", true);
                        await Navigation.PopAsync();
                    }
                    catch
                    {
                        RestClient client;
                        string     path;
                        string     result = await DisplayActionSheet("No Pack Code found would you like to create a new packcode?", "YES", "NO");

                        if (result == "YES")
                        {
                            message.DisplayMessage("Linking Codes .....", false);
                            if (PackCode != null)
                            {
                                // sending pack code to print queue
                                client         = new RestClient();
                                path           = "DocumentSQLConnection";
                                client.BaseUrl = new Uri(GoodsRecieveingApp.MainPage.APIPath + path);
                                {
                                    string str                 = $"POST?qry=INSERT INTO tblPrintQue (Barcode,Qty)VALUES('" + PackCode + "',1)";
                                    var    Request             = new RestSharp.RestRequest(str, Method.POST);
                                    CancellationTokenSource ct = new CancellationTokenSource();
                                    var res = await client.ExecuteAsync(Request, ct.Token);

                                    if (!res.IsSuccessful)
                                    {
                                        Vibration.Vibrate();
                                        message.DisplayMessage("Could not send the codes to printing", false);
                                    }
                                }
                            }
                            linkCodesInPastel(MainPage.docLines.FirstOrDefault().ItemCode, PackCode);
                            BOMItem itemB = new BOMItem();
                            itemB.PackBarcode = PackCode;
                            itemB.ItemCode    = MainPage.docLines.FirstOrDefault().ItemCode;
                            itemB.Qty         = Convert.ToInt16(txfNumberOfItem.Text);
                            itemB.ItemDesc    = MainPage.docLines.FirstOrDefault().ItemDesc;
                            await GoodsRecieveingApp.App.Database.Insert(itemB);

                            message.DisplayMessage("Complete!", true);
                            await Navigation.PopAsync();
                        }
                    }
                }
                catch
                {
                    message.DisplayMessage("No BOM created!", true);
                }
            }
        }
Example #51
0
        private void btn_pub_Click(object sender, EventArgs e)
        {
            if (cancellationTokenSource != null && !cancellationTokenSource.IsCancellationRequested)
            {
                cancellationTokenSource.Cancel();
                return;
            }

            if (!File.Exists(_linkPath))
            {
                MessageBox.Show("外链不存在请新增外链", "提示");
                return;
            }
            var links = File.ReadAllLines(_linkPath);

            if (links.Length < 1)
            {
                MessageBox.Show("外链数量较少请新增外链", "提示");
                return;
            }

            btn_pub.Text            = "取消发布";
            tbx_urls.Enabled        = false;
            cancellationTokenSource = new CancellationTokenSource();
            cancellationTokenSource.Token.Register(() =>
            {
                tbx_urls.Enabled = true;
                btn_pub.Text     = "开始发布";
            });

            var urls = tbx_urls.Lines.Where(m => Regex.IsMatch(m, @"^[a-z0-9\.\-]+$")).ToArray();

            progressBar1.Value   = 0;
            progressBar1.Maximum = links.Length;
            progressBar2.Value   = 0;
            progressBar2.Maximum = urls.Length;
            lb_total.Text        = lb_current.Text = "0/0";

            Task.Run(() =>
            {
                try
                {
                    var client       = new RestSharp.RestClient();
                    client.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36";

                    Parallel.ForEach(urls, new ParallelOptions()
                    {
                        CancellationToken = cancellationTokenSource.Token, MaxDegreeOfParallelism = Environment.ProcessorCount - 1
                    }, (u, loopstae) =>
                    {
                        if (cancellationTokenSource.IsCancellationRequested)
                        {
                            loopstae.Stop();
                        }
                        ;
                        progressBar2.Invoke(new MethodInvoker(() =>
                        {
                            progressBar1.Value = 0;
                            progressBar2.PerformStep();
                            lb_total.Text = $"{progressBar2.Value}/{progressBar2.Maximum}";
                        }));

                        int a = 0;

                        Parallel.ForEach(links, new ParallelOptions()
                        {
                            CancellationToken = cancellationTokenSource.Token, MaxDegreeOfParallelism = Environment.ProcessorCount - 1
                        }, (m, s) =>
                        {
                            try
                            {
                                var request = new RestSharp.RestRequest();
                                if (cancellationTokenSource.IsCancellationRequested)
                                {
                                    s.Stop();
                                    return;
                                }
                                var status = "";
                                if (m.Contains("{url}") && (m.StartsWith("http://") || m.StartsWith("https://")))
                                {
                                    request.Timeout  = 5000;
                                    request.Resource = m.Replace("{url}", u);
                                    var resp         = client.Get(request);
                                    status           = resp.StatusCode.ToString();
                                }
                                a += 1;
                                progressBar1.Invoke(new MethodInvoker(() =>
                                {
                                    progressBar1.Value = a;
                                    lb_current.Text    = $"{a}/{progressBar1.Maximum}";
                                    // toolTip1.ToolTipTitle = $"{u} {status}";
                                    //toolTip1.Show(request.Resource, label8);
                                    label9.Text = $"{u} {status}\r\n{request.Resource}";
                                }));
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine(ex);
                            }
                        });
                        Task.Delay(2000);
                    });

                    tbx_urls.Invoke(new MethodInvoker(() =>
                    {
                        tbx_urls.Enabled = true;
                        btn_pub.Text     = "开始发布";
                        label9.Text      = "当前任务完成";
                    }));
                }
                catch (Exception)
                {
                }
            }, cancellationTokenSource.Token);
        }
        private async Task <bool> GetItems()
        {
            if (Connectivity.NetworkAccess == NetworkAccess.Internet)
            {
                ErrorDocs.Clear();
                RestSharp.RestClient client = new RestSharp.RestClient();
                string path = "DocumentSQLConnection";
                client.BaseUrl = new Uri(GoodsRecieveingApp.MainPage.APIPath + path);
                {
                    await GetAllHeaders();

                    if (CompleteNums.Count == 0)
                    {
                        await DisplayAlert("Done", "There are no futher outstanding orders to complete!", "OK");

                        await Navigation.PopAsync();

                        return(false);
                    }
                    foreach (string strNum in CompleteNums)
                    {
                        string str     = $"GET?qry=SELECT * FROM tblTempDocLines WHERE DocNum='" + strNum + "'";
                        var    Request = new RestSharp.RestRequest();
                        Request.Resource = str;
                        Request.Method   = RestSharp.Method.GET;
                        var cancellationTokenSource = new CancellationTokenSource();
                        var res = await client.ExecuteAsync(Request, cancellationTokenSource.Token);

                        if (res.Content.ToString().Contains("DocNum"))
                        {
                            DataSet myds = new DataSet();
                            myds = Newtonsoft.Json.JsonConvert.DeserializeObject <DataSet>(res.Content);
                            foreach (DataRow row in myds.Tables[0].Rows)
                            {
                                try
                                {
                                    var Doc = new DocLine();
                                    Doc.DocNum       = row["DocNum"].ToString();
                                    Doc.SupplierCode = row["SupplierCode"].ToString();
                                    Doc.SupplierName = row["SupplierName"].ToString();
                                    Doc.ItemBarcode  = row["ItemBarcode"].ToString();
                                    Doc.ItemCode     = row["ItemCode"].ToString();
                                    Doc.ItemDesc     = row["ItemDesc"].ToString();
                                    Doc.Bin          = row["Bin"].ToString();
                                    try
                                    {
                                        Doc.ScanAccQty = Convert.ToInt32(row["ScanAccQty"].ToString().Trim());
                                    }
                                    catch
                                    {
                                        Doc.ScanAccQty = 0;
                                    }
                                    Doc.ScanRejQty = 0;
                                    try
                                    {
                                        Doc.PalletNum = Convert.ToInt32(row["PalletNumber"].ToString().Trim());
                                    }
                                    catch
                                    {
                                        Doc.PalletNum = 0;
                                    }
                                    try
                                    {
                                        Doc.Balacnce = Convert.ToInt32(row["Balacnce"].ToString().Trim());
                                    }
                                    catch
                                    {
                                        Doc.Balacnce = 0;
                                    }
                                    if (Convert.ToInt32(Doc.Balacnce) == -1)
                                    {
                                        Doc.Balacnce = 0;
                                    }
                                    Doc.ItemQty = Convert.ToInt32(row["ItemQty"].ToString().Trim());
                                    await GoodsRecieveingApp.App.Database.Insert(Doc);
                                }
                                catch (Exception ex)
                                {
                                    LodingIndiactor.IsVisible = false;
                                    Vibration.Vibrate();
                                    message.DisplayMessage("Error In Server!!" + ex, true);
                                    return(false);
                                }
                            }
                        }
                    }
                }
                PopData();
            }
            return(false);
        }
Example #53
0
        static void Main(string[] args)
        {
            int    age      = 120;
            string ageBlock = "";

            switch (age)
            {
            case 50:
                ageBlock = "the big five-oh";
                break;

            case var testAge when(new List <int>()
                                  { 80, 81, 82, 83, 84, 85, 86, 87, 88, 89 }).Contains(testAge):
                ageBlock = "octogenarian";

                break;

            case var testAge when((testAge >= 90)& (testAge <= 99)):
                ageBlock = "nonagenarian";

                break;

            case var testAge when(testAge >= 100):
                ageBlock = "centenarian";

                break;

            case var testAge when(testAge >= 110):
                ageBlock = "centenarian +";

                break;

            default:
                ageBlock = "just old";
                break;
            }


            return;

            var dbContext  = new  AutoBotContext();
            var dbContext2 = new AutoBotContext();


            var srv = new ShtrafiUserService(dbContext);
            var res = srv.RegisterDocumentSetToCheck(dbContext2.Users.FirstOrDefault(), "1621390815", "test doc set name",
                                                     "1630048283");

            return;


            var userTelegrammId = "TestUser";

            var clientId = "R413393879901";
            var key      = "dfS3s4Gfadgf9";
            var operType = 1;
            var hash     = "7f710ee37c3ff2e3587e1e1acff60ed5";



            Console.WriteLine("starting to connect...");
            var client = new RestSharp.RestClient(" https://www.elpas.ru/api.php");

            Console.WriteLine("Приветствуем вас в сервисе оплаты штрафов. У нас можно платить штрафы гибдд с низкой комиссией (10%, мин 30р). Оплата производится на надёжном сайте-партнере (moneta.ru), вы не вводите данные карт в чат.");
            Console.WriteLine("Пожалуйста введите номер свидетельства о регистрации ТС");
            var sts = Console.ReadLine();

            sts = "1621390860";

            //todo: add validation
            Console.WriteLine("Вы можете также ввести номер водительского удостоверения, это повысит вероятность поиска штрафов. Либо просто отправьте 0");
            var vu = Console.ReadLine();

            if (vu == "0")
            {
                vu = null;
            }

            var req = new RestSharp.RestRequest();

            req.AddParameter("top", "1");
            req.AddParameter("id", "R413393879901");
            req.AddParameter("hash", "7f710ee37c3ff2e3587e1e1acff60ed5");
            req.AddParameter("type", "10");
            req.AddParameter("sts", sts);
            if (vu != null)
            {
                req.AddParameter("vu", vu);
            }

            // req.Parameters.Add(new Parameter(){Name = });

            var resp = client.Post(req);
            var cont = resp.Content;

            var pays = JsonConvert.DeserializeObject <CheckPayResponse>(cont);

            //todo: add check on -1 error and 500 and repeat call if needed

            if (pays?.Err == -4)
            {
                Console.WriteLine("Штрафы не найдены. Обратите внимание что это не гарантирует на 100% их отсутсвие. Рекомендуем повторить проверку через какое-то время");
                Console.ReadLine();
            }

            var payCount = pays?.L.Count;

            if (payCount != 0)
            {
                if (payCount == 1)
                {
                    Console.WriteLine("У вас найден штраф:");
                }
                else
                {
                    Console.WriteLine($"У вас найдено {payCount} штрафов:");
                }
                int i = 1;
                foreach (var pay in pays.L)
                {
                    Console.WriteLine(i + ": " + pay.Value);
                    i++;
                }
            }

            Console.WriteLine("Перечислите номера штрафов или введите \"все\" чтобы оплатить все штрафы.");
            if (Console.ReadLine().Contains("все"))
            {
                var zkzReq = new RestSharp.RestRequest();
                zkzReq.AddParameter("top", "2");
                zkzReq.AddParameter("id", "R413393879901");
                zkzReq.AddParameter("hash", "7116af7911c223750ce58d22948f7fd8");
                zkzReq.AddParameter("type", "10");
                zkzReq.AddParameter("sts", sts);
                zkzReq.AddParameter("vu", vu);

                //начисления
                var paysJson = JsonConvert.SerializeObject(pays.L);
                zkzReq.AddParameter("l", paysJson);

                zkzReq.AddParameter("name1", "Степанов");
                zkzReq.AddParameter("name2", "Андрей");
                zkzReq.AddParameter("email", "*****@*****.**");

                zkzReq.AddParameter("flmon", "1");
                zkzReq.AddParameter("flnonotice", "1");


                var zkzResp = client.Post(zkzReq);
                var zkzCont = zkzResp.Content;
                var zkz     = JsonConvert.DeserializeObject <CreateZakazResponse>(zkzCont);

                if (zkzResp != null)
                {
                    Console.WriteLine($"Для оплаты перейдите по ссылке: {zkz.Urlpay}");
                }

                //register and check
                var  bll            = new ShtrafiBLL.ShtrafiUserService(new AutoBotContext());
                var  usr            = bll.GetUserByMessengerId(userTelegrammId);
                User registeredUser = new User();
                if (usr == null)
                {
                    registeredUser = bll.RegisterUserAfterFirstPay(userTelegrammId, "имя", "фамилия", sts, "");
                }
                Console.WriteLine($"User registered, id is {registeredUser.Id}");

                Console.WriteLine("нажмите любую кнопку чтоб отменить подписку");

                bll.ToggleDocumentSetForSubscription(registeredUser.DocumentSetsTocheck.FirstOrDefault(), false);

                Console.ReadLine();

                /* var cont = resp.Content;
                 *
                 * var pays = JsonConvert.DeserializeObject<CheckPayResponse>(cont);*/
            }

            Console.ReadLine();
        }
        public List <T> GetDataSync <T>(string filterType, string filterText)
        {
            // Set up our return data object -- a list of typed objects.
            List <T> returnData = new List <T>();

            // dch rkl 12/07/2016 capture errors with try/catch
            try
            {
                App_Settings appSettings = App.Database.GetApplicationSettings();

                // set up the proper URL
                string url = GetRestServiceUrl();
                if (!url.EndsWith(@"/"))
                {
                    url += @"/";
                }
                if ((filterType != null) &&
                    (filterType.Length > 0) &&
                    (filterText != null) &&
                    (filterText.Length > 0))
                {
                    url += @"q/" + typeof(T).Name + @"/" + filterType + @"?v=" + Uri.EscapeDataString(filterText);
                }
                else
                {
                    url += @"all/" + typeof(T).Name;
                }

                // Create a HTTP client to call the REST service
                RestSharp.RestClient client = new RestSharp.RestClient(url);

                var request = new RestSharp.RestRequest(Method.GET);
                if (appSettings.DeviceID != null)
                {
                    SimpleAES encryptText = new SimpleAES("V&WWJ3d39brdR5yUh5(JQGHbi:FB@$^@", "W4aRWS!D$kgD8Xz@");
                    string    authid      = encryptText.EncryptToString(appSettings.DeviceID);
                    string    datetimever = encryptText.EncryptToString(DateTime.Now.ToString("yyyy-MM-ddTHH:mm:sszzz"));
                    request.AddHeader("x-tdws-authid", authid);
                    request.AddHeader("x-tdws-auth", datetimever);
                }

                var response = client.Execute(request);

                // dch rkl 12/09/2016 include not found
                //if (response.StatusCode != System.Net.HttpStatusCode.OK)
                if (response.StatusCode != System.Net.HttpStatusCode.OK && response.StatusCode != System.Net.HttpStatusCode.NotFound)
                {
                    //throw new Exception("Bad request");
                    ErrorReporting errorReporting = new ErrorReporting();
                    // dch rkl 12/07/2016 add the call/sub/proc to log
                    //errorReporting.sendException(new Exception(response.Content));
                    errorReporting.sendException(new Exception(response.Content), "RestClient.cs.GetDataSync");
                }

                string JsonResult = response.Content;
                returnData = JsonConvert.DeserializeObject <List <T> >(JsonResult);
            }
            catch (Exception ex)
            {
                // dch rkl 12/07/2016 Log Error
                ErrorReporting errorReporting = new ErrorReporting();
                errorReporting.sendException(ex, string.Format("TechDashboard.RestClient.GetDataSync: FilterType={0}; FilterText={1}",
                                                               filterType, filterText));
            }

            return(returnData);
        }
Example #55
0
 public Request(string controller, Method method)
 {
     _Method      = method;
     _RestRequest = new RestSharp.RestRequest(controller, (RestSharp.Method)method);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="CustomRestRequest"/> class.
 /// </summary>
 public CustomRestRequest()
 {
     this.request = new RestRequest();
 }
Example #57
0
        public async Task <ResponseData> DangNhap(string username, string password)
        {
            try
            {
                string url     = string.Format("{0}/api/auth/login", Config.HOST);
                var    client  = new RestSharp.RestClient(url);
                var    request = new RestSharp.RestRequest(Method.POST);
                request.AddHeader("content-type", "application/json; charset=utf-8");
                request.AddJsonBody(new
                {
                    username = username,
                    password = password
                });
                var response = await client.ExecuteTaskAsync(request);

                var responseParse = Newtonsoft.Json.JsonConvert.DeserializeObject <dynamic>(response.Content);

                if (response.StatusCode == System.Net.HttpStatusCode.OK)
                {
                    UserResponse.AccessToken  = responseParse["accessToken"];
                    UserResponse.RefreshToken = responseParse["refreshToken"];
                    var employeeInfo = responseParse["employee"];
                    UserResponse.Roles = new Roles()
                    {
                        Name = employeeInfo["RoleName"]
                    };
                    UserResponse.Id       = employeeInfo["UserId"];
                    UserResponse.Username = employeeInfo["Username"];
                    UserResponse.NhanVien = new NhanVien()
                    {
                        Id         = employeeInfo["NhanVienId"],
                        Ma         = employeeInfo["MaNhanVien"],
                        Ten        = employeeInfo["TenNhanVien"],
                        GioiTinh   = employeeInfo["GioiTinh"],
                        NgaySinh   = employeeInfo["NgaySinh"],
                        DiaChi     = employeeInfo["DiaChi"],
                        SDT        = employeeInfo["SDT"],
                        CMND       = employeeInfo["CMND"],
                        Email      = employeeInfo["Email"],
                        NgayVaoLam = employeeInfo["NgayVaoLam"]
                    };

                    return(new ResponseData()
                    {
                        Status = Config.CODE_OK,
                        Data = true,
                        Message = ""
                    });
                }
                else if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
                {
                    return(new ResponseData()
                    {
                        Status = Config.CODE_UNAUTHORIZED,
                        Data = true,
                        Message = responseParse["message"]
                    });
                }
                else if (response.StatusCode == System.Net.HttpStatusCode.InternalServerError)
                {
                    return(new ResponseData()
                    {
                        Status = Config.CODE_SERVER_ERROR,
                        Data = false,
                        Message = responseParse["message"]
                    });
                }
                else
                {
                    return(null);
                }
            }
            catch (Exception ex)
            {
                return(null);
            }
        }
        private async Task <bool> GetItems(string code)
        {
            if (await RemoveAllOld(code))
            {
                if (Connectivity.NetworkAccess == NetworkAccess.Internet)
                {
                    RestSharp.RestClient client = new RestSharp.RestClient();
                    string path = "GetDocument";
                    client.BaseUrl = new Uri(GoodsRecieveingApp.MainPage.APIPath + path);
                    {
                        string str     = $"GET?qrystr=ACCHISTL|6|{code}|102|" + GoodsRecieveingApp.MainPage.UserCode;
                        var    Request = new RestSharp.RestRequest();
                        Request.Resource = str;
                        Request.Method   = RestSharp.Method.GET;
                        var cancellationTokenSource = new CancellationTokenSource();
                        var res = await client.ExecuteAsync(Request, cancellationTokenSource.Token);

                        if (res.Content.ToString().Contains("DocNum"))
                        {
                            if (!firstSO)
                            {
                                if (!await PalletAddSO())
                                {
                                    return(false);
                                }
                            }
                            await GoodsRecieveingApp.App.Database.DeleteSpecificDocs(code);

                            DataSet myds = new DataSet();
                            myds = Newtonsoft.Json.JsonConvert.DeserializeObject <DataSet>(res.Content);
                            foreach (DataRow row in myds.Tables[0].Rows)
                            {
                                try
                                {
                                    var Doc = new DocLine();
                                    Doc.DocNum       = row["DocNum"].ToString();
                                    Doc.SupplierCode = row["SupplierCode"].ToString();
                                    Doc.SupplierName = row["SupplierName"].ToString();
                                    Doc.ItemBarcode  = row["ItemBarcode"].ToString();
                                    Doc.ItemCode     = row["ItemCode"].ToString();
                                    Doc.ItemDesc     = row["ItemDesc"].ToString();
                                    Doc.Bin          = row["Bin"].ToString();
                                    try
                                    {
                                        Doc.ScanAccQty = Convert.ToInt32(row["ScanAccQty"].ToString().Trim());
                                    }
                                    catch
                                    {
                                        Doc.ScanAccQty = 0;
                                    }
                                    Doc.ScanRejQty = 0;
                                    try
                                    {
                                        Doc.PalletNum = Convert.ToInt32(row["PalletNumber"].ToString().Trim());
                                    }
                                    catch
                                    {
                                        Doc.PalletNum = 0;
                                    }
                                    currentPallet   = Doc.PalletNum;
                                    Doc.ItemQty     = Convert.ToInt32(row["ItemQty"].ToString().Trim());
                                    lblCode.Text    = Doc.DocNum;
                                    lblCusName.Text = Doc.SupplierName;
                                    await GoodsRecieveingApp.App.Database.Insert(Doc);
                                }
                                catch (Exception)
                                {
                                    LodingIndiactor.IsVisible = false;
                                    Vibration.Vibrate();
                                    message.DisplayMessage("Error In Server!!", true);
                                    return(false);
                                }
                            }
                            return(true);
                        }
                        else
                        {
                            LodingIndiactor.IsVisible = false;
                            Vibration.Vibrate();
                            message.DisplayMessage("Error Invalid SO Code!!", true);
                        }
                    }
                }
                else
                {
                    LodingIndiactor.IsVisible = false;
                    Vibration.Vibrate();
                    message.DisplayMessage("Internet Connection Problem!", true);
                }
            }
            return(false);
        }
        private async Task Complete()
        {
            try
            {
                DoneItems.Clear();
                foreach (IBTItem i in lines)
                {
                    if (!DoneItems.Contains(i.ItemCode)) {
                        DoneItems.Add(i.ItemCode);
                        string JnlAcc = await GetGlCode(i.ItemCode,i.WH);
                        int k = lines.Where(x => x.ItemCode == i.ItemCode).Sum(c=>c.ItemQtyOut);
                        RestSharp.RestClient client2 = new RestSharp.RestClient();
                        string path2 = "WHTransfer";
                        client2.BaseUrl = new Uri(GoodsRecieveingApp.MainPage.APIPath + path2);
                        {
                            string str2 = $"POST?itemCode={i.ItemCode}&JnlAcc={JnlAcc}&JnlDate={DateTime.Now.ToString("dd MMM yyyy")}&JobCode={i.iTrfID}&Desc={i.iTrfID+"-Transfer items in"}&Ref={DateTime.Now.ToString("ddMMMyyyy")+"-"+i.iTrfID}&Qty={k}&Store={CurrentHeader.ToWH}";
                            var Request2 = new RestSharp.RestRequest();
                            Request2.Resource = str2;
                            Request2.Method = RestSharp.Method.POST;
                            var cancellationTokenSource2 = new CancellationTokenSource();
                            var res2 = await client2.ExecuteAsync(Request2, cancellationTokenSource2.Token);
                            if (res2.IsSuccessful && res2.Content != null)
                            {
                                str2 = $"POST?itemCode={i.ItemCode}&JnlAcc={JnlAcc}&JnlDate={DateTime.Now.ToString("dd MMM yyyy")}&JobCode={i.iTrfID}&Desc={i.iTrfID + "-Transfer items out"}&Ref={DateTime.Now.ToString("ddMMMyyyy") + "-" + i.iTrfID}&Qty={(k/-1)}&Store={CurrentHeader.FromWH}";
                                Request2 = new RestSharp.RestRequest();
                                Request2.Resource = str2;
                                Request2.Method = RestSharp.Method.POST;
                                cancellationTokenSource2 = new CancellationTokenSource();
                                res2 = await client2.ExecuteAsync(Request2, cancellationTokenSource2.Token);
                                if (res2.IsSuccessful && res2.Content != null)
                                {
                                    RestSharp.RestClient client = new RestSharp.RestClient();
                                    string path = "IBTHeader";
                                    client.BaseUrl = new Uri(GoodsRecieveingApp.MainPage.APIPath + path);
                                    {
                                        string str = $"DELETE?coid={CurrentHeader.ID}";
                                        var Request = new RestSharp.RestRequest();
                                        Request.Resource = str;
                                        Request.Method = RestSharp.Method.DELETE;
                                        var cancellationTokenSource = new CancellationTokenSource();
                                        var res = await client.ExecuteAsync(Request, cancellationTokenSource.Token);
                                        if (res.IsSuccessful && res.Content != null)
                                        {
                                            
                                        }
										else
										{
                                            await DisplayAlert("Error","Could not upload","OK");
                                            return;
                                        }
                                    } 
                                }
                                else
                                {
                                    await DisplayAlert("Error", "Could not upload", "OK");
                                    return;
                                }
                            }
                            else if (!res2.IsSuccessful && res2.Content != null)
							{
                                await DisplayAlert("Error!",""+res2.Content.Substring(res2.Content.IndexOf("Message"),res2.Content.IndexOf("Data")-res2.Content.IndexOf("Message")),"OK");
                                return;
                            }
                            else
                            {
                                await DisplayAlert("Error", "Could not upload", "OK");
                                return;
                            }
                        }
                    }
                }               
            }
            catch(Exception ed)
            {
                await DisplayAlert("Error!", "Could not complete", "OK");
                return;
            }         
            await DisplayAlert("Complete", "Transfer complete!", "OK");
            Navigation.RemovePage(Navigation.NavigationStack[2]);
            await Navigation.PopAsync();
        }
Example #60
0
        /// <summary>
        /// Extracts data from the <paramref name="redirectUri"/> and uses it to retrieve access
        /// and refresh tokens from the provider.
        /// </summary>
        /// <param name="redirectUri">The Uri redirected to by the provider.</param>
        /// <returns>The token response, if available.</returns>
        private async Task <OAuth2TokenResponse> ProcessRedirectUri(Uri redirectUri)
        {
            // Does this represent an error?
            var queryParams = new UriBuilder(redirectUri).GetQueryParamsDictionary();

            if (queryParams.ContainsKey("error"))
            {
                throw new InvalidOperationException
                      (
                          $"Exception {queryParams["error"]} returned by authorisation endpoint."
                      );
            }

            // Check that the state was correct (not tampered with).
            if (this.oAuthPluginInfo.Configuration["state"]?.ToString() != queryParams["state"])
            {
                throw new InvalidOperationException
                      (
                          "The state returned by the authorisation endpoint was not correct."
                      );
            }

            // Retrieve the authorisation code from the URI.
            var code = queryParams.ContainsKey("code") ? queryParams["code"] : null;

            // Convert the authorisation code to tokens.

            // Create the request, adding the mandatory items.
            var tokenEndpoint = new Uri(this.oAuthPluginInfo.GetTokenEndpoint(), uriKind: UriKind.Absolute);
            var request       = new RestSharp.RestRequest(tokenEndpoint.PathAndQuery, RestSharp.Method.POST);

            request.AddParameter("code", code);
            request.AddParameter("grant_type", "authorization_code");
            request.AddParameter("redirect_uri", this.oAuthPluginInfo.GetAppropriateRedirectUri());

            // Add the client id.  If there's a realm then use that here too.
            {
                var siteRealm = this.oAuthPluginInfo.GetSiteRealm();
                var clientId  = this.oAuthPluginInfo.GetClientID();
                request.AddParameter
                (
                    "client_id",
                    string.IsNullOrWhiteSpace(siteRealm)
                                                ? clientId                  // If no site realm is supplied, just pass the client ID.
                                                : $"{clientId}@{siteRealm}" // Otherwise pass client ID @ site realm.
                );
            }

            // Add the optional bits.
            request
            .AddParameterIfNotNullOrWhitespace("resource", this.oAuthPluginInfo.GetResource())
            .AddParameterIfNotNullOrWhitespace("scope", this.oAuthPluginInfo.GetScope())
            .AddParameterIfNotNullOrWhitespace("client_secret", this.oAuthPluginInfo.GetClientSecret());

            // Execute the HTTP request.
            var restClient = new RestSharp.RestClient(tokenEndpoint.GetLeftPart(UriPartial.Authority));
            var response   = await restClient.ExecutePostAsync <OAuth2TokenResponse>(request);

            // Validate response.
            if (null == response.Data)
            {
                throw new InvalidOperationException("OAuth token not received from endpoint. Response: " + response.Content);
            }
            else if (response.Data.TokenType != "Bearer")
            {
                throw new InvalidOperationException("Token type was not bearer. Response: " + response.Content);
            }

            // Return the access token data.
            return(response.Data);
        }