Beispiel #1
0
        public object GetRequest(
            string httpMethod,
            string pathInfo,
            Dictionary <string, string> queryString,
            Dictionary <string, string> formData,
            string requestBody)
        {
            var httpHandler = GetHandler(httpMethod, pathInfo);

            var contentType = (formData != null && formData.Count > 0)
                ? MimeTypes.FormUrlEncoded
                : requestBody != null ? MimeTypes.Json : null;

            var httpReq = new MockHttpRequest(
                httpHandler.RequestName, httpMethod, contentType,
                pathInfo,
                queryString.ToNameValueCollection(),
                requestBody == null ? null : new MemoryStream(Encoding.UTF8.GetBytes(requestBody)),
                formData.ToNameValueCollection()
                );

            var request = httpHandler.CreateRequest(httpReq, httpHandler.RequestName);

            return(request);
        }
        public void ReadFromRequestAuthorizationScattered()
        {
            // Start by creating a standard POST HTTP request.
            var postedFields = new Dictionary <string, string> {
                { "age", "15" },
            };

            // Now add another field to the request URL
            var builder = new UriBuilder(MessagingTestBase.DefaultUrlForHttpRequestInfo);

            builder.Query = "Name=Andrew";

            // Finally, add an Authorization header
            var authHeaderFields = new Dictionary <string, string> {
                { "Location", "http://hostb/pathB" },
                { "Timestamp", XmlConvert.ToString(DateTime.UtcNow, XmlDateTimeSerializationMode.Utc) },
            };
            var headers = new NameValueCollection();

            headers.Add(HttpRequestHeaders.Authorization, CreateAuthorizationHeader(authHeaderFields));
            headers.Add(HttpRequestHeaders.ContentType, Channel.HttpFormUrlEncoded);

            var requestInfo = new HttpRequestInfo("POST", builder.Uri, form: postedFields.ToNameValueCollection(), headers: headers);

            IDirectedProtocolMessage requestMessage = this.channel.ReadFromRequest(requestInfo);

            Assert.IsNotNull(requestMessage);
            Assert.IsInstanceOf <TestMessage>(requestMessage);
            TestMessage testMessage = (TestMessage)requestMessage;

            Assert.AreEqual(15, testMessage.Age);
            Assert.AreEqual("Andrew", testMessage.Name);
            Assert.AreEqual("http://hostb/pathB", testMessage.Location.AbsoluteUri);
        }
Beispiel #3
0
        public static bool CreateUploadRecord(User user, DateTime reqDate, string reqType, string fileName)
        {
            // uniquekey, preqdate, customer, partner, preqtype, preqaction, pfilename, pcustomfile, presultfile, presultdate, processed
            DBConnect connection = new DBConnect();
            bool      success    = false;

            try
            {
                connection.Connect(ConnectionsMgr.GetOCConnInfo(user, _Database.Home));
                var insertVals = new Dictionary <string, string>()
                {
                    { _Column.UniqueKey, connection.GetNewKey() },
                    { _Column.PReqDate, reqDate.ToString("yyyy-MM-dd HH:mm:ss") },
                    { _Column.Customer, user.Customer.SQLEscape() },
                    { _Column.PReqType, reqType.SQLEscape() },
                    { _Column.PFileName, fileName.SQLEscape() },
                    { _Column.PCustomFile, "1" },
                    { _Column.Partner, user.ActivePartner.SQLEscape() }
                };
                using (var res = connection.Insert(_Table.ProcessQ, insertVals.ToNameValueCollection()))
                {
                    success = res.AffectedRows != 0;
                }
                connection.Close();
                return(success);
            }
            catch (Exception e)
            {
                ProgramLog.LogError(user, "ProcessQueue", "CreateUploadRecord", e.Message);
                return(false);
            }
        }
Beispiel #4
0
        /// <summary>
        /// Posts the specified data to a URL and returns the response as string asynchronously.
        /// </summary>
        public static async Task <string> PostAsync(this WebClient webClient, string url, Dictionary <string, string> postData, Encoding responseEncoding)
        {
            if (responseEncoding == null)
            {
                throw new ArgumentNullException("responseEncoding");
            }

            if (postData == null)
            {
                throw new ArgumentNullException("postData");
            }

            if (url.IsEmpty())
            {
                throw new ArgumentNullException("url");
            }

            var responseBytes = await webClient.UploadValuesTaskAsync(url, postData.ToNameValueCollection());

            try
            {
                return(responseEncoding.GetString(responseBytes));
            }
            catch (WebException ex)
            {
                throw new Exception(ex.GetResponseBody());
            }
        }
Beispiel #5
0
        public object GetRequest(
            string httpMethod,
            string pathInfo,
            Dictionary <string, string> queryString,
            Dictionary <string, string> formData,
            string requestBody)
        {
            var contentType = (formData != null && formData.Count > 0)
                ? MimeTypes.FormUrlEncoded
                : requestBody != null ? MimeTypes.Json : null;

            var httpReq = new MockHttpRequest(
                nameof(MockHttpRequest),
                httpMethod,
                contentType,
                pathInfo,
                queryString.ToNameValueCollection(),
                requestBody == null ? null : Encoding.UTF8.GetBytes(requestBody).InMemoryStream(),
                formData.ToNameValueCollection()
                );

            var httpHandler = (IRequestHttpHandler)GetHandler(httpReq);

            httpReq.OperationName = httpHandler.RequestName;

            var request = httpHandler.CreateRequestAsync(httpReq, httpHandler.RequestName).Result;

            return(request);
        }
        public void ConvertToNameValueCollection_EmptyDic_EmptyCollection()
        {
            Dictionary<int, string> d = new Dictionary<int, string>();

            NameValueCollection c = d.ToNameValueCollection();

            Assert.Empty(c);
        }
Beispiel #7
0
        public void ToNameValueCollection_EmptyDictionary()
        {
            var myDictionary = new Dictionary <string, string>();
            var collection   = myDictionary.ToNameValueCollection();

            Assert.IsNotNull(collection);
            Assert.AreEqual(0, collection.Count);
        }
Beispiel #8
0
        public void ConvertToNameValueCollection_EmptyDic_EmptyCollection()
        {
            Dictionary <int, string> d = new Dictionary <int, string>();

            NameValueCollection c = d.ToNameValueCollection();

            Assert.Empty(c);
        }
Beispiel #9
0
        public object ExecutePath(
            string httpMethod,
            string pathInfo,
            Dictionary <string, string> queryString,
            Dictionary <string, string> formData,
            string requestBody)
        {
            var httpHandler = GetHandler(httpMethod, pathInfo);

            var contentType = (formData != null && formData.Count > 0)
                ? ContentType.FormUrlEncoded
                : requestBody != null ? ContentType.Json : null;

            var httpReq = new MockHttpRequest(
                httpHandler.RequestName, httpMethod, contentType,
                pathInfo,
                queryString.ToNameValueCollection(),
                requestBody == null ? null : new MemoryStream(Encoding.UTF8.GetBytes(requestBody)),
                formData.ToNameValueCollection()
                );

            var request  = httpHandler.CreateRequest(httpReq, httpHandler.RequestName);
            var response = httpHandler.GetResponse(httpReq, null, request);

            var httpRes = response as IHttpResult;

            if (httpRes != null)
            {
                var httpError = httpRes as IHttpError;
                if (httpError != null)
                {
                    throw new WebServiceException(httpError.Message)
                          {
                              StatusCode  = httpError.Status,
                              ResponseDto = httpError.Response
                          };
                }
                var hasResponseStatus = httpRes.Response as IHasResponseStatus;
                if (hasResponseStatus != null)
                {
                    var status = hasResponseStatus.ResponseStatus;
                    if (status != null && !status.ErrorCode.IsNullOrEmpty())
                    {
                        throw new WebServiceException(status.Message)
                              {
                                  StatusCode  = (int)HttpStatusCode.InternalServerError,
                                  ResponseDto = httpRes.Response,
                              };
                    }
                }

                return(httpRes.Response);
            }

            return(response);
        }
Beispiel #10
0
        public void ToNameValueCollection()
        {
            var @this = new Dictionary <string, string> {
                { "Fizz", "Buzz" }
            };

            var result = @this.ToNameValueCollection();

            Assert.AreEqual("Buzz", result["Fizz"]);
        }
Beispiel #11
0
        public static bool Submit(HttpRequest request, ReportDetail req, string usUserName, string usCustomer, string usPartner)
        {
            if (request == null || req == null)
            {
                return(false);
            }
            DBConnect connectionAdmin = new DBConnect();

            try
            {
                connectionAdmin.Connect(new DatabaseInfo(ConnectionsMgr.GetAdminConnInfo())
                {
                    Database = databaseEmailRequest
                });

                string defaultToEmail   = "*****@*****.**";
                string defaultFromEmail = "*****@*****.**";

                StringBuilder builtMessage = new StringBuilder();
                builtMessage.AppendLine("From: " + req.Name);
                builtMessage.AppendLine("Company: " + req.Company);
                builtMessage.AppendLine("Email: " + req.Email);
                builtMessage.AppendLine("Message: " + req.Message);
                builtMessage.AppendLine();
                builtMessage.AppendLine("Additional Info");
                builtMessage.AppendLine("IP Address: " + request.UserHostAddress);
                builtMessage.AppendLine("Browser Info: " + request.UserAgent);
                builtMessage.AppendLine("Referral: " + request.UrlReferrer.ToString());
                DateTime requestTime = DateTime.Now;
                var      vals        = new Dictionary <string, string>()
                {
                    { columnUniqueKey, connectionAdmin.GetNewKey() },
                    { columnCustomer, (usCustomer ?? "").SQLEscape() },
                    { columnPartner, (usPartner ?? "").SQLEscape() },
                    { columnRequestDate, requestTime.ToString("yyyy-MM-dd HH:mm:ss") },
                    { columnToEmail, defaultToEmail },
                    { columnFromEmail, defaultFromEmail },
                    { columnSubject, "EDIOC- Support Submission" },
                    { columnMessage, WrapTextTo70(builtMessage.ToString().SQLEscape()) },
#if DEBUG
                    { columnProcessed, "Y" },
#else
                    { columnProcessed, "" },
#endif
                    { columnSendAfter, requestTime.ToString("yyyy-MM-dd HH:mm:ss") }
                };
                var result = connectionAdmin.Insert(tableEmailReq, vals.ToNameValueCollection());
                return(result.AffectedRows > 0);
            }
            catch (Exception e)
            {
                ProgramLog.LogError(usUserName, usCustomer, usPartner, "SupportRequest", "Submit", e.Message);
                return(false);
            }
        }
        private NameValueCollection ParseBody(string bodyLines)
        {
            var    items  = new Dictionary <string, string>();
            var    parser = new EslStringReader(bodyLines);
            string name   = parser.Read(':', true);

            while (!parser.EOF &&
                   !string.IsNullOrEmpty(name))
            {
                string value = parser.ReadLine(true);
                if (!items.ContainsKey(name.Trim()))
                {
                    try { items.Add(name.Trim(), Uri.UnescapeDataString(value.Trim())); }
                    catch (UriFormatException) {
                        // add the value unformatted
                        items.Add(name.Trim(), value.Trim());
                    }
                }
                name = parser.Read(':', true);
            }

            var extraContents = new List <string>();

            while (!parser.EOF)
            {
                string line = parser.ReadLine(true);
                if (!string.IsNullOrEmpty(line))
                {
                    extraContents.Add(line.Trim());
                }
            }

            if (extraContents.Count <= 0)
            {
                return(items.ToNameValueCollection());
            }
            if (!items.ContainsKey("__CONTENT__"))
            {
                items.Add("__CONTENT__", String.Join("|", extraContents));
            }
            return(items.ToNameValueCollection());
        }
        public void ToNameValueCollection()
        {
            // Type
            var @this = new Dictionary<string, string> {{"Fizz", "Buzz"}};

            // Exemples
            NameValueCollection result = @this.ToNameValueCollection(); // return a NameValueCollection

            // Unit Test
            Assert.AreEqual("Buzz", result["Fizz"]);
        }
        public void ConvertToNameValue_SomeRefTypeAsValue_ToStringUsedToConvertTheValue()
        {
            Dictionary<int, MyType> d = new Dictionary<int, MyType>
                {
                    {1, new MyType("Some value")}
                };

            NameValueCollection c = d.ToNameValueCollection();

            Assert.Equal("Some value", c[0]);
        }
Beispiel #15
0
        public void ConvertToNameValueCollection_NotStringForKey_ToStringForTKeyUsed()
        {
            Dictionary <int, string> d = new Dictionary <int, string>
            {
                { 1, "Value1" }
            };

            NameValueCollection c = d.ToNameValueCollection();

            Assert.Equal("Value1", c["1"]);
        }
Beispiel #16
0
        private static async Task <TResponse> ApiQueryAsync <TResponse>(string apiName, Dictionary <string, object> param, CancellationToken token)
        {
            using (var client = new HttpClient())
            {
                var response = await client.GetAsync(BaseUrl + apiName + param.ToNameValueCollection().ToQueryString(), token).ConfigureAwait(false);

                var result = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

                return(JsonConvert.DeserializeObject <TResponse>(result));
            }
        }
Beispiel #17
0
        public void ConvertToNameValue_SomeRefTypeAsValue_ToStringUsedToConvertTheValue()
        {
            Dictionary <int, MyType> d = new Dictionary <int, MyType>
            {
                { 1, new MyType("Some value") }
            };

            NameValueCollection c = d.ToNameValueCollection();

            Assert.Equal("Some value", c[0]);
        }
Beispiel #18
0
        public void ConvertToNameValueCollection_NullForValue_ConvertToEmptyString()
        {
            Dictionary <int, string> d = new Dictionary <int, string>
            {
                { 1, null }
            };

            NameValueCollection c = d.ToNameValueCollection();

            Assert.Equal(string.Empty, c[0]);
        }
        public void ConvertToNameValue_ConvertFunction_ConvertFunctionUsedToConvertTheValue()
        {
            Dictionary<int, MyType> d = new Dictionary<int, MyType>
                {
                    {1, new MyType("Some value")}
                };

            NameValueCollection c = d.ToNameValueCollection(type => "converted value");

            Assert.Equal("converted value", c[0]);
        }
        public void ConvertToNameValueCollection_NullForValue_ConvertToEmptyString()
        {
            Dictionary<int, string> d = new Dictionary<int, string>
                {
                    {1, null}
                };

            NameValueCollection c = d.ToNameValueCollection();

            Assert.Equal(string.Empty, c[0]);
        }
        public void ConvertToNameValueCollection_NotStringForKey_ToStringForTKeyUsed()
        {
            Dictionary<int, string> d = new Dictionary<int, string>
                {
                    {1, "Value1"}
                };

            NameValueCollection c = d.ToNameValueCollection();

            Assert.Equal("Value1", c["1"]);
        }
Beispiel #22
0
        public void ConvertToNameValue_ConvertFunction_ConvertFunctionUsedToConvertTheValue()
        {
            Dictionary <int, MyType> d = new Dictionary <int, MyType>
            {
                { 1, new MyType("Some value") }
            };

            NameValueCollection c = d.ToNameValueCollection(type => "converted value");

            Assert.Equal("converted value", c[0]);
        }
Beispiel #23
0
        public void ToNameValueCollection_DictionarySize1()
        {
            var myDictionary = new Dictionary <string, string>
            {
                { "key1", "value1" }
            };
            var collection = myDictionary.ToNameValueCollection();

            Assert.IsNotNull(collection);
            Assert.AreEqual(1, collection.Count);
            Assert.AreEqual("value1", collection.Get("key1"));
        }
Beispiel #24
0
        public void ConvertToNameValueCollection_MoreElements_SameOrderInCollection()
        {
            Dictionary <int, string> d = new Dictionary <int, string>
            {
                { 1, "Value1" },
                { 2, "Value2" }
            };

            NameValueCollection c = d.ToNameValueCollection();

            Assert.Equal("Value1", c[0]);
            Assert.Equal("Value2", c[1]);
        }
    public void ToNameValueCollection_creates_equivalent_collection()
    {
      Dictionary<string,string> test = new Dictionary<string, string>();
      test.Add("foo", "bar");
      test.Add("spong", "wibble");

      NameValueCollection output = test.ToNameValueCollection();

      Assert.IsNotNull(output, "Null");
      Assert.AreEqual(2, output.Count, "Count");
      Assert.AreEqual("bar", output["foo"], "foo");
      Assert.AreEqual("wibble", output["spong"], "spong");
    }
Beispiel #26
0
        public void ToNameValueCollection()
        {
            // Type
            var @this = new Dictionary <string, string> {
                { "Fizz", "Buzz" }
            };

            // Exemples
            NameValueCollection result = @this.ToNameValueCollection(); // return a NameValueCollection

            // Unit Test
            Assert.AreEqual("Buzz", result["Fizz"]);
        }
        public void ConvertToNameValueCollection_MoreElements_SameOrderInCollection()
        {
            Dictionary<int, string> d = new Dictionary<int, string>
                {
                    {1, "Value1"},
                    {2, "Value2"}
                };

            NameValueCollection c = d.ToNameValueCollection();

            Assert.Equal("Value1", c[0]);
            Assert.Equal("Value2", c[1]);
        }
        public void TestToNameValueCollection()
        {
            Dictionary <string, string> test = new Dictionary <string, string>();

            test.Add("foo", "bar");
            test.Add("spong", "wibble");

            NameValueCollection output = test.ToNameValueCollection();

            Assert.IsNotNull(output, "Null");
            Assert.AreEqual(2, output.Count, "Count");
            Assert.AreEqual("bar", output["foo"], "foo");
            Assert.AreEqual("wibble", output["spong"], "spong");
        }
        public void When_making_dictionary_into_namevaluecollection_Then_works()
        {
            var dict = new Dictionary <int, bool>()
            {
                { 1, true },
                { 2, false }
            };

            var nvc = dict.ToNameValueCollection(key => (key + 1).ToString(), value => (!value).ToString());

            Assert.That(nvc.Keys, Has.Count.EqualTo(2));
            Assert.That(nvc["2"], Is.EqualTo("False"));
            Assert.That(nvc["3"], Is.EqualTo("True"));
        }
        public string Get(string url, Dictionary<string, string> headers)
        {
            var req = (HttpWebRequest)WebRequest.Create(url);
            req.Headers.Add(headers.ToNameValueCollection());

            Debug.WriteLine(url);

            using(var response = (HttpWebResponse)req.GetResponse())
            using(var responseStream = response.GetResponseStream())
            using(var sr = new StreamReader(responseStream))
            {
                return sr.ReadToEnd().Trim();
            }
        }
        public void TestExtentsion_DictionaryToNameValueCollection()
        {
            var dict = new Dictionary<string,string>()
            {
                { "key1", "val1" },
                { "key2", "val2" },
                { "key3", "val3" },
                { "key4", "val4" },
                { "key5", "val5" },
            };

            var nvc = dict.ToNameValueCollection();
            Assert.IsTrue((nvc["key3"] == "val3"));
        }
Beispiel #32
0
        public string Get(string url, Dictionary <string, string> headers)
        {
            var req = (HttpWebRequest)WebRequest.Create(url);

            req.Headers.Add(headers.ToNameValueCollection());

            Debug.WriteLine(url);

            using (var response = (HttpWebResponse)req.GetResponse())
                using (var responseStream = response.GetResponseStream())
                    using (var sr = new StreamReader(responseStream))
                    {
                        return(sr.ReadToEnd().Trim());
                    }
        }
Beispiel #33
0
        public void IDictionaryTest_ToNameValueCollection_001()
        {
            IDictionary <string, string> dict = new Dictionary <string, string> {
                { "One", "1" },
                { "Two", "22" }
            };

            var actual = dict.ToNameValueCollection();

            Assert.AreEqual(2, actual.Count);
            Assert.AreEqual("1", actual[0]);
            Assert.AreEqual("1", actual["One"]);
            Assert.AreEqual("22", actual[1]);
            Assert.AreEqual("22", actual["Two"]);
        }
Beispiel #34
0
        public async Task CreateLoginAsync(string type, Dictionary <string, string> values)
        {
            var selectedLogin = _logins.Where(x => x.Type == type)
                                .FirstOrDefault();

            if (selectedLogin == null)
            {
                throw new Exception($"Login do tipo {type} não encontrado");
            }

            var requestContext = values.ToNameValueCollection();

            await selectedLogin.ValidateLoginAsync(new RequestContext()
            {
                Values = requestContext
            });
        }
Beispiel #35
0
        private async Task <T> ExecutePostAsync <T>(string method, IDictionary <string, string> parameters = null)
        {
            var moment = GetTimestamp();

            var content = new Dictionary <string, string>()
            {
                { "method", method },
                { "moment", moment.ToString() }
            };

            if (parameters != null)
            {
                foreach (var parameter in parameters)
                {
                    content.Add(parameter.Key, parameter.Value);
                }
            }

            var queryParams = content
                              .ToNameValueCollection()
                              .ToQueryString();

            var signature = GetSignature(queryParams, _apiSecret);

            if (!_httpClient.DefaultRequestHeaders.Contains("API-Key"))
            {
                _httpClient.DefaultRequestHeaders.Add("API-Key", _apiKey);
            }

            _httpClient.DefaultRequestHeaders.Remove("API-Hash");

            _httpClient.DefaultRequestHeaders.Add("API-Hash", signature);

            var response = await _httpClient.PostAsync(_privateBaseAddress,
                                                       new FormUrlEncodedContent(content));

            response.EnsureSuccessStatusCode();

            var json = await response.Content.ReadAsStringAsync();

            var responseData = JsonConvert.DeserializeObject <T>(json);

            return(responseData);
        }
Beispiel #36
0
        private static void _Log(string username, string customer, string partner, string source, string method, string type, string message)
        {
            if (customer == "")
            {
                customer = "EDIO";
            }
            if (partner == "")
            {
                partner = "EDIO";
            }
            string sCustomer = TruncateAndEscape(customer, 4);
            string sPartner  = TruncateAndEscape(partner, 4);
            string sUsername = TruncateAndEscape(username, 40);
            string sSource   = TruncateAndEscape(source, 32);
            string sMethod   = TruncateAndEscape(method, 32);
            string sMessage  = (string.IsNullOrWhiteSpace(message) ? "" : message).SQLEscape();
            bool   isTest    = false;

#if DEBUG
            isTest = true;
#endif
            var connection = new DBConnect();
            try
            {
                connection.Connect(ConnectionsMgr.GetAdminConnInfo());
                Dictionary <string, string> insertVals = new Dictionary <string, string>()
                {
                    { _Column.UniqueKey, connection.GetNewKey() },
                    { columnLogTime, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") },
                    { columnSource, sSource },
                    { columnMethod, sMethod },
                    { columnStatus, type },
                    { columnMessage, sMessage },
                    { _Column.UserName, sUsername },
                    { _Column.Customer, sCustomer },
                    { _Column.Partner, sPartner },
                    { columnIsTest, isTest ? "1" : "0" }
                };
                connection.Insert(tableLog, insertVals.ToNameValueCollection());
            }
            catch { }
            connection.Close();
        }
        /// <summary>
        /// Compiles the configuration into a dictionary.
        /// </summary>
        /// <returns></returns>
        public NameValueCollection Build()
        {
            // default settings
            var c = new Dictionary <string, string>();

            // apply configuration from sources
            foreach (var source in sources)
            {
                foreach (var kvp in source.GetConfiguration())
                {
                    c[kvp.Key] = kvp.Value;
                }
            }

            // log for the user
            logger.LogInformation("Providing Quartz configuration: {Configuration}", c);

            // caller expects NVC
            return(c.ToNameValueCollection());
        }
 public void Test_DictionaryExtensions_ToNameValueCollection()
 {
     var dict = new Dictionary<string, string> { { "name", "value" } };
     var coll = dict.ToNameValueCollection();
     Assert.AreEqual(dict.Count, coll.Count);
     foreach (KeyValuePair<string, string> pair in dict)
     {
         bool keyExists = false;
         for (int i = 0; i < coll.Keys.Count; i++)
         {
             if (coll.Keys[i] == pair.Key)
             {
                 keyExists = true;
                 break;
             }
         }
         Assert.IsTrue(keyExists);
         Assert.AreEqual(pair.Value, coll[pair.Key]);
     }
 }
        private NameValueCollection ParseHeader(string headerLines) {
            var items = new Dictionary<string, string>();
            var parser = new EslStringReader(headerLines);
            string name = parser.Read(':', true);
            while (!parser.EOF
                   && name != string.Empty) {
                string value = parser.ReadLine(true);
                if (!items.ContainsKey(name.Trim())) {
                    try { items.Add(name.Trim(), Uri.UnescapeDataString(value.Trim())); }
                    catch (UriFormatException) {
                        // add the value unformatted
                        items.Add(name.Trim(), value.Trim());
                    }
                }

                name = parser.Read(':', true);
            }

            return items.ToNameValueCollection();
        }
Beispiel #40
0
        public static void SendRequest(User user, ReportRequestData ord)
        {
            string storesConcat = "";

            if (ord.Stores.Count > 0)
            {
                storesConcat = string.Format("STORE IN ({1})", _Column.STId, string.Join(",", from store in ord.Stores select "'" + store.SQLEscape() + "'"));
            }
            string retailConcat = string.Join("; ", from week in ord.Weeks select week.ToSQL());
            var    genDate      = DateTime.Now;

            try
            {
                var connection = ConnectionsMgr.GetAdminConnection();
                {
                    var vals = new Dictionary <string, string>()
                    {
                        { _Column.UniqueKey, connection.GetNewKey() },
                        { _Column.RequestDate, genDate.ToMySQLDateTimeStr() },
                        { _Column.Customer, user.Customer.SQLEscape() },
                        { _Column.ConnectID, user.OCConnID.SQLEscape() },
                        { _Column.OutputName, string.Format("{0}_{1}_{2}.xlsx", user.Customer.SQLEscape(), 852, genDate.ToString("yyyyMMddHHmmssF")) },
                        { _Column.OutputPath, string.Format(@"\ecgb\data\networks\{0}\outbox", user.OCConnID.SQLEscape()) },
                        { _Column.Filter, string.Format("{0}|{1}|{2}|{3}", ord.RequestType, storesConcat, retailConcat, user.ActivePartner.SQLEscape()) },
                        { _Column.Processed, _ProgressFlag.Unprocessed },
                        { _Column.ToEmail, ord.Email.SQLEscape() },
                        { _Column.OptCenterUpload, "1" }
                    };
                    connection.Insert(_Table.SalesRequest, vals.ToNameValueCollection());
                }
                connection.Close();
            }
            catch (Exception e)
            {
                ProgramLog.LogError(user, "SalesRequestManager", "GetStoreList", e.Message);
            }
        }
Beispiel #41
0
        public static void DoChanges(User user, UpdateData updateData)
        {
            Dictionary <string, string> updateDistroVals = new Dictionary <string, string>()
            {
                { columnReviewSun, updateData.days[0] ? "1" : "0" },
                { columnReviewMon, updateData.days[1] ? "1" : "0" },
                { columnReviewTue, updateData.days[2] ? "1" : "0" },
                { columnReviewWed, updateData.days[3] ? "1" : "0" },
                { columnReviewThu, updateData.days[4] ? "1" : "0" },
                { columnReviewFri, updateData.days[5] ? "1" : "0" },
                { columnReviewSat, updateData.days[6] ? "1" : "0" },
                { columnMinDollars, updateData.minDollars.ToString() },
                { columnDayRange, updateData.dayRange.ToString() }
            };

            try
            {
                DBConnect connection = ConnectionsMgr.GetSharedConnection(user, _Database.ESIC);
                {
                    connection.Update(tableDistroDays, updateDistroVals.ToNameValueCollection(), string.Format("WHERE {0}='{1}'", _Column.Partner, user.ActivePartner.SQLEscape()));

                    foreach (var kvp in updateData.itemInfo)
                    {
                        string qtymin = kvp.Value.Min.ToString();
                        string qtymax = kvp.Value.Max.ToString();
                        string qtyreo = kvp.Value.Reorder.ToString();
                        string vennum = kvp.Key;
                        connection.Query(string.Format(qUpdateItems, vennum.SQLEscape(), qtymin.SQLEscape(), qtymax.SQLEscape(), qtyreo.SQLEscape(), user.ActivePartner.SQLEscape()));
                    }
                }
                connection.Close();
            }
            catch (Exception e)
            {
                ProgramLog.LogError(user, "ItemTable", "DoChanges", e.Message);
            }
        }
        private NameValueCollection ParseHeader(string headerLines)
        {
            var    items  = new Dictionary <string, string>();
            var    parser = new EslStringReader(headerLines);
            string name   = parser.Read(':', true);

            while (!parser.EOF &&
                   name != string.Empty)
            {
                string value = parser.ReadLine(true);
                if (!items.ContainsKey(name.Trim()))
                {
                    try { items.Add(name.Trim(), Uri.UnescapeDataString(value.Trim())); }
                    catch (UriFormatException) {
                        // add the value unformatted
                        items.Add(name.Trim(), value.Trim());
                    }
                }

                name = parser.Read(':', true);
            }

            return(items.ToNameValueCollection());
        }
		public void ReadFromRequestAuthorizationScattered() {
			// Start by creating a standard POST HTTP request.
			var postedFields = new Dictionary<string, string> {
				{ "age", "15" },
			};

			// Now add another field to the request URL
			var builder = new UriBuilder(MessagingTestBase.DefaultUrlForHttpRequestInfo);
			builder.Query = "Name=Andrew";

			// Finally, add an Authorization header
			var authHeaderFields = new Dictionary<string, string> {
				{ "Location", "http://hostb/pathB" },
				{ "Timestamp", XmlConvert.ToString(DateTime.UtcNow, XmlDateTimeSerializationMode.Utc) },
			};
			var headers = new NameValueCollection();
			headers.Add(HttpRequestHeaders.Authorization, CreateAuthorizationHeader(authHeaderFields));
			headers.Add(HttpRequestHeaders.ContentType, Channel.HttpFormUrlEncoded);

			var requestInfo = new HttpRequestInfo("POST", builder.Uri, form: postedFields.ToNameValueCollection(), headers: headers);

			IDirectedProtocolMessage requestMessage = this.channel.ReadFromRequest(requestInfo);

			Assert.IsNotNull(requestMessage);
			Assert.IsInstanceOf<TestMessage>(requestMessage);
			TestMessage testMessage = (TestMessage)requestMessage;
			Assert.AreEqual(15, testMessage.Age);
			Assert.AreEqual("Andrew", testMessage.Name);
			Assert.AreEqual("http://hostb/pathB", testMessage.Location.AbsoluteUri);
		}
        private NameValueCollection ParseBody(string bodyLines) {
            var items = new Dictionary<string, string>();
            var parser = new EslStringReader(bodyLines);
            string name = parser.Read(':', true);
            while (!parser.EOF
                   && !string.IsNullOrEmpty(name)) {
                string value = parser.ReadLine(true);
                if (!items.ContainsKey(name.Trim())) {
                    try { items.Add(name.Trim(), Uri.UnescapeDataString(value.Trim())); }
                    catch (UriFormatException) {
                        // add the value unformatted
                        items.Add(name.Trim(), value.Trim());
                    }
                }
                name = parser.Read(':', true);
            }

            var extraContents = new List<string>();
            while (!parser.EOF) {
                string line = parser.ReadLine(true);
                if (!string.IsNullOrEmpty(line)) extraContents.Add(line.Trim());
            }

            if (extraContents.Count <= 0) return items.ToNameValueCollection();
            if (!items.ContainsKey("__CONTENT__")) items.Add("__CONTENT__", String.Join("|", extraContents));
            return items.ToNameValueCollection();
        }