public void Cast_ConvertsDecimalParamCorrectly() { var parameters = new Hashtable {{"NetFramework", "4.5"}}; var sut = parameters.Cast<SingleDecimalParameter>(); Assert.Equal(4.5M, sut.NetFramework); }
public void Cast_CastsParametersWithDotNotation() { var parameters = new Hashtable { { "Octopus.Machine.Name", "some machine name" } }; var sut = parameters.Cast<DotNotationParameter>(); Assert.Equal("some machine name", sut.OctopusMachineName); }
private string Download(string uri, Hashtable vars) { // 1. format query string if (vars != null) { var query = vars.Cast<DictionaryEntry>().Aggregate("", (current, d) => current + ("&" + d.Key.ToString() + "=" + d.Value.ToString())); if (query.Length > 0) { uri = uri + "?" + query.Substring(1); } } // 2. setup basic authenication var authstring = Convert.ToBase64String( Encoding.ASCII.GetBytes(String.Format("{0}:{1}", _id, _token))); // 3. perform GET using WebClient var client = new WebClient(); client.Headers.Add("Authorization", String.Format("Basic {0}", authstring)); var resp = client.DownloadData(uri); return Encoding.ASCII.GetString(resp); }
public void Cast_DoesNotThrowWhenNotRequiredParamNotGiven() { var parameters = new Hashtable {{"SiteName", "MySite"}}; var sut = parameters.Cast<RequiredParameters>(); Assert.Equal("MySite", sut.SiteName); }
public void Cast_ConvertsShortParamCorrectly() { var parameters = new Hashtable {{"Port", "80"}}; var sut = parameters.Cast<SingleShortParameter>(); Assert.Equal(80, sut.Port); }
public static Dictionary<string, object> HashtableToDict(Hashtable hashtable) { if (hashtable == null) { return new Dictionary<string, object>(); } return hashtable.Cast<DictionaryEntry>().ToDictionary( kvp => (string) kvp.Key.ToString(), kvp => (object) kvp.Value ); }
public Model.Webhook CreateWebhook( string resourceGroupName, string automationAccountName, string name, string runbookName, bool isEnabled, DateTimeOffset expiryTime, Hashtable runbookParameters) { Requires.Argument("ResourceGroupName", resourceGroupName).NotNull(); Requires.Argument("AutomationAccountName", automationAccountName).NotNull(); using (var request = new RequestSettings(this.automationManagementClient)) { var rbAssociationProperty = new RunbookAssociationProperty { Name = runbookName }; var createOrUpdateProperties = new WebhookCreateOrUpdateProperties { IsEnabled = isEnabled, ExpiryTime = expiryTime, Runbook = rbAssociationProperty, Uri = this.automationManagementClient .Webhooks.GenerateUri( resourceGroupName, automationAccountName).Uri }; if (runbookParameters != null) { createOrUpdateProperties.Parameters = runbookParameters.Cast<DictionaryEntry>() .ToDictionary(kvp => (string)kvp.Key, kvp => (string)kvp.Value); } var webhookCreateOrUpdateParameters = new WebhookCreateOrUpdateParameters( name, createOrUpdateProperties); var webhook = this.automationManagementClient.Webhooks.CreateOrUpdate( resourceGroupName, automationAccountName, webhookCreateOrUpdateParameters).Webhook; return new Model.Webhook( resourceGroupName, automationAccountName, webhook, webhookCreateOrUpdateParameters.Properties.Uri); } }
private string Upload(string uri, string method, Hashtable vars) { // 1. format body data var data = ""; if (vars != null) { data = vars.Cast<DictionaryEntry>().Aggregate(data, (current, d) => current + (d.Key.ToString() + "=" + d.Value.ToString() + "&")); } // 2. setup basic authenication var authstring = Convert.ToBase64String(Encoding.ASCII.GetBytes(String.Format("{0}:{1}", _id, _token))); // 3. perform POST/PUT/DELETE using WebClient ServicePointManager.Expect100Continue = false; var postbytes = Encoding.ASCII.GetBytes(data); var client = new WebClient(); client.Headers.Add("Authorization", String.Format("Basic {0}", authstring)); client.Headers.Add("Content-Type", "application/x-www-form-urlencoded"); var resp = client.UploadData(uri, method, postbytes); return Encoding.ASCII.GetString(resp); }
private static void GeraSoluction(ParametrosCriarProjetos parametros, string guidProjTO, string guidProjDAL, string guidProjInterface, string guidProjBLL, string guidProjWcf) { var trocasSolution = new Hashtable { {"[guid]", Guid.NewGuid().ToString().ToUpper().ToUpper()}, {"[namespace]", parametros.NameSpace}, {"[guidTO]", guidProjTO}, {"[guidDAL]", guidProjDAL}, {"[guidInterface]", guidProjInterface}, {"[guidBLL]", guidProjBLL} }; var projSolution = Gerador.RetornaTextoBase("noituloS"); if (parametros.MapWcf) { projSolution = projSolution.Replace("[guidWcf]", string.Format("Project(\"{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}\") = \"{0}Wcf\", \"{0}Wcf\\{0}Wcf.csproj\", \"{{53034ACE-081D-4CDA-8075-D3B158C7DAF9}}\"{1}EndProject", parametros.NameSpace, Environment.NewLine)); projSolution = projSolution.Replace("[guidGlobalWcf]", string.Format("{{{0}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU{1}{{{0}}}.Debug|Any CPU.Build.0 = Debug|Any CPU{1}{{{0}}}.Release|Any CPU.ActiveCfg = Release|Any CPU{1}{{{0}}}.Release|Any CPU.Build.0 = Release|Any CPU", guidProjWcf, Environment.NewLine)); } else { projSolution = projSolution.Replace("[guidWcf]", ""); projSolution = projSolution.Replace("[guidGlobalWcf]", ""); } switch (parametros.VersaoFramework) { case "v2.0": projSolution = projSolution.Replace("2010", "2008"); projSolution = projSolution.Replace("11.00", "10.00"); break; case "v4.5": projSolution = projSolution.Replace("2010", "2012"); projSolution = projSolution.Replace("11.00", "12.00"); break; } projSolution = trocasSolution.Cast<DictionaryEntry>().Aggregate(projSolution, (current, entry) => current.Replace(entry.Key.ToString(), entry.Value.ToString())); File.WriteAllText(string.Format("{0}\\{1}.sln", parametros.CaminhoDestino, parametros.NameSpace), projSolution); }
private static void GeraProjetoInterface(ParametrosCriarProjetos parametros, string guidProjInterface, List<string> arquivosInterface, string templateAssembly) { var trocasInterface = new Hashtable { {"[guid]", guidProjInterface}, {"[namespace]", parametros.NameSpace}, {"[arquivos]", string.Join("\n", arquivosInterface.ToArray())} }; var projInterface = Gerador.RetornaTextoBase("secafretnIetalpmeT"); projInterface = trocasInterface.Cast<DictionaryEntry>().Aggregate(projInterface, (current, entry) => current.Replace(entry.Key.ToString(), entry.Value.ToString())); projInterface = projInterface.Replace("[versao]", parametros.VersaoFramework); var assemblyInterface = templateAssembly.Replace("[log]", ""); assemblyInterface = assemblyInterface.Replace("[namespace]", parametros.NameSpace); assemblyInterface = assemblyInterface.Replace("[guid]", guidProjInterface); File.WriteAllText(string.Format("{0}\\Interfaces\\{1}Interfaces.csproj", parametros.CaminhoDestino, parametros.NameSpace), projInterface); File.WriteAllText(string.Format("{0}\\Interfaces\\Properties\\AssemblyInfo.cs", parametros.CaminhoDestino), assemblyInterface); }
private static void GeraProjetoDal(ParametrosCriarProjetos parametros, string provider, string guidProjDAL, string guidProjInterface, string guidProjTO, List<string> arquivosDAL, StringBuilder sbLog4Net, string templateAssembly) { var trocasDAL = new Hashtable { {"[guid]", guidProjDAL}, {"[namespace]", parametros.NameSpace}, {"[guidInterface]", guidProjInterface}, {"[guidTO]", guidProjTO}, {"[provider]", string.Format("<Compile Include=\"DataDrain\\Factories\\{0}.cs\" />", provider)}, {"[arquivos]", string.Join("\n", arquivosDAL.ToArray())}, }; var projDAL = Gerador.RetornaTextoBase("SSLADetalpmet").Replace("[log]", ""); projDAL = trocasDAL.Cast<DictionaryEntry>().Aggregate(projDAL, (current, entry) => current.Replace(entry.Key.ToString(), entry.Value.ToString())); projDAL = projDAL.Replace("[versao]", parametros.VersaoFramework); var assemblyDAL = templateAssembly.Replace("[camada]", "DAL").Replace("[log]", ""); assemblyDAL = assemblyDAL.Replace("[namespace]", parametros.NameSpace); assemblyDAL = assemblyDAL.Replace("[guid]", guidProjDAL); File.WriteAllText(string.Format("{0}\\DAL\\{1}DAL.csproj", parametros.CaminhoDestino, parametros.NameSpace), projDAL); File.WriteAllText(string.Format("{0}\\DAL\\Properties\\AssemblyInfo.cs", parametros.CaminhoDestino), assemblyDAL); }
private static void GeraProjetoBll(ParametrosCriarProjetos parametros, string guidProjBLL, string guidProjInterface, string guidProjTO, string guidProjDAL, List<string> arquivosBLL, StringBuilder sbLog4Net, string templateAssembly) { var trocasBLL = new Hashtable { {"[guid]", guidProjBLL}, {"[namespace]", parametros.NameSpace}, {"[guidInterface]", guidProjInterface}, {"[guidTO]", guidProjTO}, {"[guidDAL]", guidProjDAL}, {"[arquivos]", string.Join("\n", arquivosBLL.ToArray())}, }; var projBLL = Gerador.RetornaTextoBase("LLBetalpmet").Replace("[log]", ""); projBLL = trocasBLL.Cast<DictionaryEntry>().Aggregate(projBLL, (current, entry) => current.Replace(entry.Key.ToString(), entry.Value.ToString())); projBLL = projBLL.Replace("[versao]", parametros.VersaoFramework); var assemblyBLL = templateAssembly.Replace("[camada]", "bll").Replace("[log]", ""); assemblyBLL = assemblyBLL.Replace("[namespace]", parametros.NameSpace); assemblyBLL = assemblyBLL.Replace("[guid]", guidProjBLL); File.WriteAllText(string.Format("{0}\\BLL\\{1}BLL.csproj", parametros.CaminhoDestino, parametros.NameSpace), projBLL); File.WriteAllText(string.Format("{0}\\BLL\\Properties\\AssemblyInfo.cs", parametros.CaminhoDestino), assemblyBLL); }
public void Cast_IgnoresExtraNotRequiredParameters() { var parameters = new Hashtable {{"SiteName", "MySite"}, {"ApplicationPoolName", "AppPool1"}}; var sut = parameters.Cast<InstallerContextTests.SingleStringParameter>(); Assert.Equal("MySite", sut.SiteName); }
/// <summary> /// VHSoft: Add function to handle complex searching; converting the json object from jqgrid to workable sql where string /// </summary> private void ConvertComplexSearchObjectToSQL(Hashtable searchObject, ref string where, ref string additionalSQL) { Dictionary<string, object> value2 = searchObject.Cast<DictionaryEntry> ().ToDictionary(kvp => (string)kvp.Key, kvp => (object)kvp.Value); this.ConvertComplexSearchObjectToSQL(value2, ref where, ref additionalSQL); }
public static Dictionary<string, object> HashtableToDictionary(Hashtable table) { return table .Cast<DictionaryEntry>() .ToDictionary(kvp => (string)kvp.Key, kvp => kvp.Value); }
public string Request(string path, string method, Hashtable vars) { string response; if (path == null || path.Length <= 0) throw (new ArgumentException("Invalid path parameter")); method = method.ToUpper(); if (method == null || (method != "GET" && method != "POST" && method != "PUT" && method != "DELETE")) { throw (new ArgumentException("Invalid method parameter")); } if (method != "GET" && vars.Count <= 0) { throw (new ArgumentException("No vars parameters")); } var url = _build_uri(path); try { response = method == "GET" ? Download(url, vars) : Upload(url, method, vars); } catch (WebException e) { var message = e.Message; switch (e.Status) { case WebExceptionStatus.TrustFailure: message = "You do not trust the people who issued the certificate being used by twiliorest.dll."; break; } var varList = vars.Cast<DictionaryEntry>().Aggregate("", (current, d) => current + ("&" + d.Key.ToString() + "=" + d.Value.ToString())); var responseStr = ""; Stream responseStream = null; if (e.Response != null) responseStream = e.Response.GetResponseStream(); if (responseStream != null) using (var sr = new StreamReader(responseStream)) { string line; while ((line = sr.ReadLine()) != null) { responseStr += line; } } message = String.Format("TwilioRestException occurred in the request you sent: \n{0}\n\tURLL: {1}\n\tMETHOD:{2}\n\tVARS:{3}\n\tRESPONSE:{4}", message, url, method, varList, responseStr); throw new TwilioRestException(message, e); } return response; }
public void Cast_ThrowsWhenTypeNotCompatibleWithShort() { var parameters = new Hashtable {{"Port", "blah"}}; Exception sut = Catch.Exception(() => parameters.Cast<SingleShortParameter>()); Assert.IsType<ParameterCastException>(sut); Assert.Equal("Cannot cast to type System.Int16 for parameter name Port", sut.Message); }
public void Cast_ThrowsWhenTypeNotCompatibleWithFloat() { var parameters = new Hashtable {{"NetFramework", "blah"}}; Exception sut = Catch.Exception(() => parameters.Cast<SingleFloatParameter>()); Assert.IsType<ParameterCastException>(sut); Assert.Equal("Cannot cast to type System.Single for parameter name NetFramework", sut.Message); }
public void Cast_ThrowsWhenRequiredParameterIsNotGiven() { var parameters = new Hashtable {{"Port", "80"}}; Exception sut = Catch.Exception(() => parameters.Cast<RequiredParameters>()); Assert.IsType<RequiredParameterNotGivenException>(sut); Assert.Equal("Parameter SiteName is required please specify it.", sut.Message); }
public void Cast_SetsAllParameters() { var parameters = new Hashtable {{"Port", "80"}, {"SiteName", "MySite"}, {"AppPoolName", "AppPool1"}}; var sut = parameters.Cast<MultipleParameters>(); Assert.Equal(80, sut.Port); Assert.Equal("MySite", sut.SiteName); Assert.Equal("AppPool1", sut.AppPoolName); }
public Model.Webhook UpdateWebhook( string resourceGroupName, string automationAccountName, string name, Hashtable parameters, bool? isEnabled) { Requires.Argument("ResourceGroupName", resourceGroupName).NotNull(); Requires.Argument("AutomationAccountName", automationAccountName).NotNull(); using (var request = new RequestSettings(this.automationManagementClient)) { var webhookModel = this.automationManagementClient.Webhooks.Get(resourceGroupName, automationAccountName, name).Webhook; var webhookPatchProperties = new WebhookPatchProperties(); if (webhookModel != null) { if (isEnabled != null) { webhookPatchProperties.IsEnabled = isEnabled.Value; } if (parameters != null) { webhookPatchProperties.Parameters = parameters.Cast<DictionaryEntry>() .ToDictionary(kvp => (string)kvp.Key, kvp => (string)kvp.Value); } } var webhookPatchParameters = new WebhookPatchParameters(name) { Properties = webhookPatchProperties }; var webhook = this.automationManagementClient.Webhooks.Patch( resourceGroupName, automationAccountName, webhookPatchParameters).Webhook; return new Model.Webhook(resourceGroupName, automationAccountName, webhook); } }
public static void SetTemplateMetadata(ProvisioningTemplate template, string templateDisplayName, string templateImagePreviewUrl, Hashtable templateProperties) { if (!String.IsNullOrEmpty(templateDisplayName)) { template.DisplayName = templateDisplayName; } if (!String.IsNullOrEmpty(templateImagePreviewUrl)) { template.ImagePreviewUrl = templateImagePreviewUrl; } if (templateProperties != null && templateProperties.Count > 0) { var properties = templateProperties .Cast<DictionaryEntry>() .ToDictionary(i => (String)i.Key, i => (String)i.Value); foreach (var key in properties.Keys) { if (!String.IsNullOrEmpty(key)) { template.Properties[key] = properties[key]; } } } }
private static void GeraProjetoTo(Configuration parametros, string guidProjTO, string guidProjInterface, List<string> arquivosTO, string templateAssembly) { var trocasTo = new Hashtable { {"[guid]", guidProjTO}, {"[namespace]", parametros.NameSpace}, {"[guidInterface]", guidProjInterface}, {"[arquivos]", string.Join("\n", arquivosTO.ToArray())} }; var projTO = FileFactory.RetornaTextoBase("OTetalpmet"); projTO = trocasTo.Cast<DictionaryEntry>().Aggregate(projTO, (current, entry) => current.Replace(entry.Key.ToString(), entry.Value.ToString())); projTO = projTO.Replace("[versao]", parametros.VersaoFramework); var assemblyTO = templateAssembly.Replace("[camada]", "TO").Replace("[log]", ""); assemblyTO = assemblyTO.Replace("[namespace]", parametros.NameSpace); assemblyTO = assemblyTO.Replace("[guid]", guidProjTO); File.WriteAllText(string.Format("{0}\\TO\\{1}TO.csproj", parametros.DestinationPath, parametros.NameSpace), projTO); File.WriteAllText(string.Format("{0}\\TO\\Properties\\AssemblyInfo.cs", parametros.DestinationPath), assemblyTO); }
private static List<Hashtable> GenerateList(DocumentCollection oldDc) { var ds = from d in _client.CreateDocumentQuery<PostMessage>(oldDc.DocumentsLink) where d.Type == "Post" select d; Hashtable hs = new Hashtable(); Hashtable newList = new Hashtable(); Hashtable oldList = new Hashtable(); var n = ds.ToList().Count; foreach (var d in ds) { if (!hs.ContainsKey(d.Path.District)) { hs.Add(d.Path.District, 1); } else { hs[d.Path.District] = (int) hs[d.Path.District] + 1; } } foreach (DictionaryEntry h in hs) { var c = newList.Cast<DictionaryEntry>().Aggregate(0, (current, hh) => current + (int) hh.Value); if (c < n*0.45 && (c + (int) h.Value < n*0.55)) { newList.Add(h.Key, h.Value); } else { oldList.Add(h.Key, h.Value); } } return new List<Hashtable> {oldList, newList}; }
public void Cast_OnlySetsWritableProperties() { var parameters = new Hashtable { { "Port", 80 } }; var sut = parameters.Cast<ReadonlyParameter>(); Assert.Equal(90, sut.Port); }
private static Dictionary<string, string> ToDictionary(Hashtable hashTable) { return hashTable.Cast<DictionaryEntry>().ToDictionary(kvp => kvp.Key.ToString(), kvp => kvp.Value.ToString()); }
public void Cast_GivesParametersWhenSuppliedUsingCorrectCasing() { var parameters = new Hashtable {{"SiteName", "MySite"}}; var sut = parameters.Cast<InstallerContextTests.SingleStringParameter>(); Assert.Equal("MySite", sut.SiteName); }
private static Dictionary<string, string> HashtableToDictionary(Hashtable table) { return table .Cast<DictionaryEntry>() .ToDictionary(kvp => (string)kvp.Key, kvp => (string)kvp.Value); }
public static Dictionary <K, V> ToDictionary <K, V>(this Hashtable table) { return(table .Cast <DictionaryEntry>() .ToDictionary(kvp => (K)kvp.Key, kvp => (V)kvp.Value)); }