private void Search(Dictionary<int, int> count, IList<int> temp, IList<IList<int>> results) { if (!count.Any() && temp.Any()) { results.Add(new List<int>(temp)); return; } var keys = count.Keys.ToList(); foreach (var key in keys) { temp.Add(key); --count[key]; if (count[key] == 0) count.Remove(key); Search(count, temp, results); temp.RemoveAt(temp.Count - 1); if (count.ContainsKey(key)) { ++count[key]; } else { count[key] = 1; } } }
public override DbExpression Visit(DbScanExpression expression) { // a bit harder to get the metadata in CSpace var item = expression.Target.ElementType.MetadataProperties.First(p => p.Name == "Configuration"); // using reflection to get the Annotations property as EntityTtypeConfiguration is an internal class in EF Dictionary<string, object> annotations = new Dictionary<string, object>(); var value = item.Value; var propertyInfo = value.GetType().GetProperty("Annotations"); if (propertyInfo != null) { annotations = (Dictionary<string, object>) propertyInfo.GetValue(value, null); } if (!annotations.Any()) { return base.Visit(expression); } DbExpression current = expression; foreach (var globalFilter in annotations.Where(a => a.Key.StartsWith("globalFilter"))) { var convention = (FilterDefinition)globalFilter.Value; Filter filterConfig; string filterName = globalFilter.Key.Split(new[] { "globalFilter_" }, StringSplitOptions.None)[1]; if (!FilterExtensions.FilterConfigurations.TryGetValue(new Tuple<string, object>(filterName, _contextForInterception.GetInternalContext()), out filterConfig)) continue; if (!filterConfig.IsEnabled) continue; var linqExpression = convention.Predicate(_contextForInterception, filterConfig.ParameterValues); var funcletizerType = typeof(DefaultExpressionVisitor).Assembly.GetType( "System.Data.Entity.Core.Objects.ELinq.Funcletizer"); var funcletizerFactoryMethod = funcletizerType.GetMethod("CreateQueryFuncletizer", BindingFlags.Static | BindingFlags.NonPublic); var funcletizer = funcletizerFactoryMethod.Invoke(null, new[] { _objectContext }); var converterType = typeof(DefaultExpressionVisitor).Assembly.GetType( "System.Data.Entity.Core.Objects.ELinq.ExpressionConverter"); var converter = Activator.CreateInstance(converterType, BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { funcletizer, linqExpression }, null); var convertMethod = converterType.GetMethod("Convert", BindingFlags.NonPublic | BindingFlags.Instance); var result = (DbFilterExpression)convertMethod.Invoke(converter, null); var binding = current.Bind(); var normalizer = new BindingNormalizer(binding); var output = result.Predicate.Accept(normalizer); current = binding.Filter(output); } return current; }
public static IDictionary<Version, ChangeLogVersionDetails> GetChangeLog(Version fromVersion, Version toVersion, XDocument changeLogContent) { var changeLog = new Dictionary<Version, ChangeLogVersionDetails>(); foreach (var changeVersion in changeLogContent.Descendants("Version")) { var changeLogItem = BuildChangeLogItem(changeVersion); if (!changeLog.ContainsKey(changeLogItem.Key)) { changeLog.Add(changeLogItem.Key, changeLogItem.Value); } } if (fromVersion < toVersion && changeLog.Any(x => x.Key > fromVersion && x.Key <= toVersion)) { return changeLog.Where(x => x.Key > fromVersion && x.Key <= toVersion).OrderByDescending(detail => detail.Key).ToDictionary(detail => detail.Key, detail => detail.Value); } if (fromVersion < toVersion && changeLog.Any() && toVersion > changeLog.Keys.Max()) { return changeLog.Where(x => x.Key == changeLog.Keys.Max()).ToDictionary(detail => detail.Key, detail => detail.Value); } if (fromVersion < toVersion && toVersion.Revision > 0 && changeLog.Any() && toVersion < changeLog.Keys.Max()) { var versionWithoutRevision = new Version(toVersion.Major, toVersion.Minor, toVersion.Build); return changeLog.Where(x => x.Key > versionWithoutRevision).ToDictionary(detail => detail.Key, detail => detail.Value); } return changeLog.OrderByDescending(detail => detail.Key).ToDictionary(detail => detail.Key, detail => detail.Value); }
/// <summary>метод который формирует данные для chart-а на основе колекции серий, /// поинтов и их пересечений </summary> private SeriesCollection FillData( Dictionary<string, float> seriesDef, Dictionary<string, float> pointDef, Dictionary<Intersection, float> intersections) { SeriesCollection result = new SeriesCollection(); if (!subDiagramMode) { switch (this.DiagramType) { case DiagramTypeEnum.Graph: result.Add(CreateDataForFullDiagram(seriesDef, pointDef, intersections, true)); break; case DiagramTypeEnum.ColumnDetail: result.Add(CreateDataForFullDiagram(seriesDef, pointDef, intersections, false)); break; case DiagramTypeEnum.ColumnGeneral: result.Add(CreateDataForColumnGeneral(seriesDef)); break; case DiagramTypeEnum.PieGeneral: result.Add(CreateDataForPieGeneral(seriesDef)); break; case DiagramTypeEnum.Speedometer: case DiagramTypeEnum.TrafficLight: if (seriesDef.Any( s => s.Key.Equals(defaultSeries))) result.Add(FillSeriesData(seriesDef.First(s => s.Key.Equals(defaultSeries)))); break; case DiagramTypeEnum.PieDetail: if (seriesDef.Any(s => s.Key.Equals(defaultSeries))) result.Add(FillPointsData(seriesDef.First(s => s.Key.Equals(defaultSeries)), pointDef, intersections, false)); break; } } else { if (string.IsNullOrEmpty(detalizedSeriesName)) detalizedSeriesName = this.defaultSeries; if (seriesDef.Any(s => s.Key.Equals(detalizedSeriesName))) { switch (this.SubDiagramType) { case SubDiagramTypeEnum.Graph: case SubDiagramTypeEnum.ColumnDetail: case SubDiagramTypeEnum.PieDetail: result.Add(FillPointsData(seriesDef.First(s => s.Key.Equals(detalizedSeriesName)), pointDef, intersections, false)); break; } } } FillEmptyVisibleSeries(seriesDef.Keys.ToList()); return result; }
private void AssertAditionals(Dictionary<string, string> additionals) { if(additionals == null) return; if(additionals.Count > MaxAdditionalsCount) throw new ArgumentException(); if(additionals.Any( a => a.Key.Length > MaxAdditionalKeyLenght)) throw new ArgumentException(); if(additionals.Any(( a => a.Value.Length > MaxAdditionalValueLenght))) throw new ArgumentException(); }
public void CreateLiveConnectFoldersSkyDrive(Dictionary<string, object> folderDictionary, EventHandler<LiveOperationCompletedEventArgs> callback) { if (folderDictionary.Any()) { CreateLiveConnectFolders("me/skydrive", folderDictionary, callback); } }
public List<Dictionary<string, object>> Parse(IRestResponse<dynamic> responseToParse, ParserRules ruleset) { if (responseToParse.ResponseStatus != ResponseStatus.Completed) throw new ApplicationException("Response was not [Completed]"); if (responseToParse.Data == null) throw new ApplicationException("Response data could not be parsed"); var resultset = responseToParse.Data as IEnumerable<dynamic>; if (resultset == null) throw new ApplicationException("Response data could not be identified as collection"); List<Dictionary<string, object>> l = new List<Dictionary<string, object>>(); foreach (Dictionary<string, object> item in resultset) { var newItem = new Dictionary<string, object>(); foreach (var field in ruleset.Fields) { if (item.ContainsKey(field.Selector)) { newItem.Add(field.Selector, item[field.Selector]); } } if (newItem.Any()) l.Add(newItem); } return l; }
public override IEnumerable<string> Executar(Grafo grafo) { grafo.Direcionado = true; var retorno = new List<string>(); Dictionary<string, Vertice> Q = new Dictionary<string, Vertice>(); var primeiro = grafo.Vertices.First(); Q.Add(primeiro.Key, primeiro.Value); while (Q.Any()) { var U = Q.First(); Q.Remove(Q.Keys.First()); foreach (var vertice in grafo.GetAdj(U.Key)) { if (vertice.Value.Cor == CoresEnum.Branco) { vertice.Value.Descoberta = U.Value.Descoberta + 1; vertice.Value.Pai = U.Value; vertice.Value.Cor = CoresEnum.Cinza; Q.Add(vertice.Key, vertice.Value); } } retorno.Add(String.Format("{0} {1} {2}", grafo.Vertices.First().Key, U.Value.Id, U.Value.Descoberta)); U.Value.Cor = CoresEnum.Preto; } return retorno; }
public virtual Dictionary<string, object> GetRecognizeData(byte[] image, string condition = "") { Dictionary<string, object> dic = new Dictionary<string, object>(); try { DateTime timestamp = DateTime.Now; var templates = Directory.EnumerateFiles(_templatePath).Where(f => new[] { ".xml" }.Contains(Path.GetExtension(f))); foreach (string template in templates.Where(t => t.Contains(condition))) { OnTry(template); dic = GetRecognizeDataByTemplate(image, template); if (dic.Any()) { OnRecognizeData(DateTime.Now - timestamp, template); return dic; } } } catch(Exception ex) { OnError(ex); } return dic; }
internal static ClassDeclarationSyntax GetNonCollectible() { while(true) { var newNamingConflicts = new Dictionary<string, List<string>>(); var classDecl = ClassDeclaration("NonCollectible").AddModifiers(Token(PublicKeyword)); foreach(var c in ClassNames) { var className = c == "DREAM" ? "DreamCards" : CultureInfo.InvariantCulture.TextInfo.ToTitleCase(c.ToLower()); var cCard = ClassDeclaration(className).AddModifiers(Token(PublicKeyword)); var anyCards = false; foreach(var card in Cards.All.OrderBy(x => x.Value.Set) .ThenBy(x => x.Key) .Select(x => x.Value) .Where(x => !x.Collectible && x.Class.ToString().Equals(c))) { var name = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(card.Name.ToLower()); name = Regex.Replace(name, @"[^\w\d]", ""); name = ResolveNameFromId(card, name); name = ResolveNamingConflict(name, card, newNamingConflicts); cCard = cCard.AddMembers(GenerateConst(name, card.Id)); anyCards = true; } if(anyCards) classDecl = classDecl.AddMembers(cCard); } if(!newNamingConflicts.Any(x => x.Value.Count > 1)) return classDecl; foreach(var pair in newNamingConflicts.Where(x => x.Value.Count > 1).ToDictionary(pair => pair.Key, pair => pair.Value)) _namingConflicts.Add(pair.Key, pair.Value); } }
internal List<Right> GetBexisRights(string dataBase, Dictionary<int, int> dataSetsMapping) { List<Right> bexisRights = new List<Right>(); string datasetQuery = ""; foreach (var dataSetMapping in dataSetsMapping) { datasetQuery += "DATASETID = "+ dataSetMapping.Key; if (dataSetsMapping.Last().Key != dataSetMapping.Key) datasetQuery += " or "; } if (dataSetsMapping.Any()) { datasetQuery = "where " + datasetQuery + ""; } // DB query string mySelectQuery = "SELECT ROLENAME, DATASETID, FOREDIT, APPLICATIONNAME FROM \"PROVIDER\".\"RIGHTS\" "+ datasetQuery; DB2Connection connect = new DB2Connection(dataBase); DB2Command myCommand = new DB2Command(mySelectQuery, connect); connect.Open(); DB2DataReader myReader = myCommand.ExecuteReader(); while (myReader.Read()) { bexisRights.Add(new Right() { RoleName = myReader.GetString(0), DataSetId = (int)(myReader.GetValue(1)), CanEdit = myReader.GetString(2)=="N"?false:true }); } myReader.Close(); connect.Close(); return bexisRights; }
public async Task<IDictionary<string, Result>> GetBatchSentimentAsync(Dictionary<string, string> textBatch) { ValidateBatchRequest(textBatch); if (!textBatch.Any()) { return new Dictionary<string, Result>(); } string content; using (var response = await _requestor.PostAsync(Constants.SentimentBatchRequest, BuildInputString(textBatch))) { content = await response.Content.ReadAsStringAsync(); if (!response.IsSuccessStatusCode) { return textBatch.ToDictionary(r => r.Key, r => AzureMachineLearningResult.Build(_errorMessageGenerator.GenerateError(response.StatusCode, content))); } } var result = JsonConvert.DeserializeObject<SentimentBatchResult>(content); var parsedResults = result.SentimentBatch.ToDictionary(sr => sr.Id, sr => AzureMachineLearningResult.Build(sr.Score, ScoreToSentiment(sr.Score))); foreach (var error in result.Errors) { parsedResults.Add(error.Id, AzureMachineLearningResult.Build(error.Message)); } return parsedResults; }
public HttpWorker(Uri uri, HttpMethod httpMethod = HttpMethod.Get, Dictionary<string, string> headers = null, byte[] data = null) { _buffer = new byte[8192]; _bufferIndex = 0; _read = 0; _responseType = ResponseType.Unknown; _uri = uri; IPAddress ip; var headersString = string.Empty; var contentLength = data != null ? data.Length : 0; if (headers != null && headers.Any()) headersString = string.Concat(headers.Select(h => "\r\n" + h.Key.Trim() + ": " + h.Value.Trim())); if (_uri.HostNameType == UriHostNameType.Dns) { var host = Dns.GetHostEntry(_uri.Host); ip = host.AddressList.First(i => i.AddressFamily == AddressFamily.InterNetwork); } else { ip = IPAddress.Parse(_uri.Host); } _endPoint = new IPEndPoint(ip, _uri.Port); _request = Encoding.UTF8.GetBytes($"{httpMethod.ToString().ToUpper()} {_uri.PathAndQuery} HTTP/1.1\r\nAccept-Encoding: gzip, deflate, sdch\r\nHost: {_uri.Host}\r\nContent-Length: {contentLength}{headersString}\r\n\r\n"); if (data == null) return; var tmpRequest = new byte[_request.Length + data.Length]; Buffer.BlockCopy(_request, 0, tmpRequest, 0, _request.Length); Buffer.BlockCopy(data, 0, tmpRequest, _request.Length, data.Length); _request = tmpRequest; }
/// <summary> /// To do. Create a clever search algorithm. /// </summary> /// <param name="Word"></param> /// <param name="Collection"></param> /// <returns></returns> public string GetSimilar(string Word, List<string> Collection) { if (Word.IsNullOrEmpty()) { return Word; } Dictionary<string, int> keys = new Dictionary<string, int>(); /*foreach (string s in words.Keys) { if (s.EndsWith(Word)) { keys.Add(s, s.Length); } }*/ Collection.AsParallel().ForAll(s => { if (s.EndsWith(Word)) { keys.Add(s, s.Length); } }); if (!keys.Any() && Word.Length > 2) { return this.GetSimilar(Word.Substring(1), Collection); } string key = keys.OrderBy(val => val.Value).FirstOrDefault().Key; return key; }
public void VisaData(IList<AktivPeriod> perioder) { panel1.Controls.Clear(); var lista = new Dictionary<DateTime, double>(); foreach (var dag in perioder.Select(o => o.Starttid.Date).Distinct()) { var summeradDag = dag; lista.Add(dag, perioder.Where(o => o.Starttid.Date.Equals(summeradDag)).Sum(o => o.Tidsmängd.TotalMinutes)); } if (!lista.Any()) return; var max = lista.Max(o => o.Value); var xposition = 10; foreach (var d in lista) { var stapel = new Dagstapel { Height = panel1.Height - 20, Top = 10, Left = xposition }; stapel.VisaUppgifter(d.Key, d.Value, max); xposition += stapel.Width; panel1.Controls.Add(stapel); } }
public override void Respond(Abstractions.IHttpContext context) { var prefetcherDocs = Database.IndexingExecuter.PrefetchingBehavior.DebugGetDocumentsInPrefetchingQueue().ToArray(); var compareToCollection = new Dictionary<Etag, int>(); for (int i = 1; i < prefetcherDocs.Length; i++) compareToCollection.Add(prefetcherDocs[i-1].Etag, prefetcherDocs[i].Etag.CompareTo(prefetcherDocs[i-1].Etag)); if (compareToCollection.Any(x => x.Value < 0)) { context.WriteJson(new { HasCorrectlyOrderedEtags = true, EtagsWithKeys = prefetcherDocs.ToDictionary(x => x.Etag, x => x.Key) }); } else { context.WriteJson(new { HasCorrectlyOrderedEtags = false, IncorrectlyOrderedEtags = compareToCollection.Where(x => x.Value < 0), EtagsWithKeys = prefetcherDocs.ToDictionary(x => x.Etag, x => x.Key) }); } }
protected virtual bool GetMatchedRecords( IOrderedEnumerable<IRecord> recordsFilteredByDate, IModelInput modelInput, out IDictionary<string, IList<IRecord>> matchedRecords ) { matchedRecords = new Dictionary<string, IList<IRecord>>(); if (!recordsFilteredByDate.AnySave()) { return false; } foreach (var record in recordsFilteredByDate) { foreach (var term in modelInput.FilterTerms) { var distinctMatchedDescription = GetMatchedDistinctDescription(record.Description, term); record.DistinctDescription = distinctMatchedDescription; if (string.IsNullOrEmpty(distinctMatchedDescription)) { continue; } if (matchedRecords.ContainsKey(distinctMatchedDescription)) { matchedRecords[distinctMatchedDescription].Add(record); } else { matchedRecords.Add(distinctMatchedDescription, new List<IRecord>() { record }); } break; } } return matchedRecords.Any(); }
private static void AddLinkHeaders(NancyContext context, IEnumerable<Tuple<string, IEnumerable<Tuple<IResponseProcessor, ProcessorMatch>>>> compatibleHeaders, Response response) { var linkProcessors = new Dictionary<string, MediaRange>(); var compatibleHeaderMappings = compatibleHeaders.SelectMany(m => m.Item2).SelectMany(p => p.Item1.ExtensionMappings); foreach (var compatibleHeaderMapping in compatibleHeaderMappings) { if (!compatibleHeaderMapping.Item2.Matches(response.ContentType)) { linkProcessors[compatibleHeaderMapping.Item1] = compatibleHeaderMapping.Item2; } } if (!linkProcessors.Any()) { return; } var baseUrl = context.Request.Url.BasePath + "/" + Path.GetFileNameWithoutExtension(context.Request.Url.Path); var links = linkProcessors.Keys .Select(lp => string.Format("<{0}.{1}>; rel=\"{2}\"", baseUrl, lp, linkProcessors[lp])) .Aggregate((lp1, lp2) => lp1 + "," + lp2); response.Headers["Link"] = links; }
public void Progress(Dictionary<string, string> namedParameters, string[] parameters) { if (parameters.Length != 2 && parameters.Length != 1) { throw new ArgumentOutOfRangeException("parameters", "Parameter count must be at least one"); } bool deleteParents = namedParameters.Any( a => string.Compare("--delete-parents", a.Key, StringComparison.InvariantCultureIgnoreCase) == 0); string maxDepthResult = CommandHelper.GetProperty(namedParameters, "--max-depth", null); int maxDepth = maxDepthResult == null ? 0 : int.Parse(maxDepthResult); var issuer = CommandHelper.GetProperty (namedParameters, "--issuer", Environment.UserName); string comment = CommandHelper.GetProperty(namedParameters, "--comment", "Backup combination"); string zip = parameters[0]; string resultPath = parameters.Length == 2 ? parameters[1] : Path.GetTempFileName (); bool overrideZip = parameters.Length == 1; Backup.Combine(zip, resultPath, maxDepth, issuer, comment); if (overrideZip) File.Move(zip, resultPath); }
public void CoursesCorrelation(List<string> callStack, Dictionary<string, decimal> coursesCatalog, List<string> coursesList) { while (coursesCatalog.Any(coursePointer => coursePointer.Value < 0)) { callStack.Clear(); var courseTarget = coursesCatalog.First(coursePointer => coursePointer.Value < 0).Key; while (courseTarget != "loop" && courseTarget != "base") { courseTarget = recursiveInsight(courseTarget, callStack, coursesCatalog, coursesList); } if (courseTarget == "loop") { foreach (var coursePointer in callStack) coursesCatalog[coursePointer] = 0.1M; } if (courseTarget == "base") { var courseLevelSetup = callStack.Count; foreach (var coursePointer in callStack) { coursesCatalog[coursePointer] = courseLevelSetup; courseLevelSetup--; } } } }
internal static void Deserialize(CharacterFilterBase filter, Dictionary<string, object> fieldDict) { if (fieldDict == null || !fieldDict.Any()) return; filter.Version = fieldDict.GetDoubleOrNull(_VERSION); }
protected void Page_Load(object sender, EventArgs e) { MyProjects = RequestContext.CurrentUserProjects; InitControls(); IsProjectAdmin = Page.Participant.IsAdmin; IsFullAdmin = Page.Participant.IsFullAdmin; IsOutsider = Page.Participant.UserInfo.IsOutsider(); ParticipantSecurityInfo = new Dictionary<string, bool> { {"Project", IsProjectAdmin}, {"Milestone", RequestContext.CanCreateMilestone()}, {"Task", RequestContext.CanCreateTask()}, {"Discussion", RequestContext.CanCreateDiscussion()}, {"Time", RequestContext.CanCreateTime()}, {"ProjectTemplate", IsProjectAdmin} }; ShowCreateButton = (ParticipantSecurityInfo.Any(r => r.Value) || Page is TMDocs) && !Page.Participant.UserInfo.IsOutsider(); var mobileAppRegistrator = new CachedMobileAppInstallRegistrator(new MobileAppInstallRegistrator()); var currentUser = CoreContext.UserManager.GetUsers(SecurityContext.CurrentAccount.ID); var isRegistered = mobileAppRegistrator.IsInstallRegistered(currentUser.Email, null); DisplayAppsBanner = SetupInfo.DisplayMobappBanner("projects") && !CoreContext.Configuration.Standalone && !isRegistered; }
/// <summary> /// Ensures the appropriate version of the specified packages are installed. If an existing version of the package /// already exists the following will happen: /// If a semantically compatible version already exists, no change is made to the package. /// If an older major version exists, a warning is logged and the package is upgraded. /// If an older minor/build version exists, an information message is logged and the package is upgraded. /// If a newer major version exists, a warning is logged and no change is made to the package. /// </summary> public static async Task InstallPackagesAsync( Dictionary<string, string> packages, string extensionId, ConnectedServiceLogger logger, Project project, IVsPackageInstallerServices packageInstallerServices, IVsPackageInstaller packageInstaller) { Dictionary<string, string> packagesToInstall = new Dictionary<string, string>(); await NuGetUtilities.InstallPackagesAsync( project, packages, (packageId, packageVersion) => { packagesToInstall.Add(packageId, packageVersion); return Task.FromResult<object>(null); }, logger, packageInstallerServices); if (packagesToInstall.Any()) { packageInstaller.InstallPackagesFromVSExtensionRepository(extensionId, false, false, project, packagesToInstall); } }
//Returns the location of bracket mismatch //Rewrite this to make use of better suited container for brackets public int GetBracketMismatch(string code) { Dictionary<char, char> bracketMap = new Dictionary<char, char>() { {'{', '}'}, {'(', ')'}, {'[', ']'}, {'<', '>'} };//, {'\'', '\''} }; //{} () [] <> "" '' Stack<char> bracketStack = new Stack<char>(); int counter = 0; foreach (char c in code) { if("(){}<>".Contains(c)) { if (!")}>".Contains(c)) { bracketStack.Push(c); } else if (bracketMap.Any(q => q.Key == bracketMap[bracketStack.Last()])) { bracketStack.Pop(); } else { return counter; } } counter++; } return -1; }
public override IEnumerable<string> Executar(Grafo grafo) { var retorno = new List<string>(); grafo.Direcionado = true; initialize(grafo); var s = grafo.Vertices.First(); s.Value.Descoberta = 0; Dictionary<string, Vertice> q = new Dictionary<string, Vertice>(); List<Vertice> w = new List<Vertice>(); q = grafo.Vertices; while (q.Any()) { q.OrderBy(e => e.Value.Descoberta).ToList(); var u = q.First(); q.Remove(q.Keys.First()); foreach (var vertice in grafo.GetAdj(u.Value.Id)) { var aresta = grafo.Arestas .Where(e => e.Origem.Equals(u.Key) && e.Destino.Equals(vertice.Key)) .FirstOrDefault(); relax(u.Value, vertice.Value, aresta.Peso); } if (u.Value.Descoberta != Int32.MaxValue) retorno.Add(String.Format("{0} {1} {2}", s.Value.Id, u.Value.Id, u.Value.Descoberta)); } return retorno; }
public void DictionaryExtensions_Any_ReturnsFalseIfDictionaryDoesNotContainItems() { var dictionary = new Dictionary<Int32, String>(); var result = dictionary.Any(); TheResultingValue(result).ShouldBe(false); }
public static void HandleErrorDict(ModelStateDictionary stateDictionary, Dictionary<string, string> validationsDictionary) { if (validationsDictionary.Any()) { stateDictionary.AddModelError(String.Empty, "Please review and correct the noted errors."); } foreach (KeyValuePair<string, string> valuePair in validationsDictionary) { stateDictionary.AddModelError(valuePair.Key, valuePair.Value); } }
/// <summary> /// Loads the current configuration setting the internal state of this configuration context. /// </summary> /// <param name="bucketConfig"></param> /// <param name="force">True to force a reconfiguration.</param> /// <exception cref="CouchbaseBootstrapException">Condition.</exception> public override void LoadConfig(IBucketConfig bucketConfig, bool force = false) { if (bucketConfig == null) throw new ArgumentNullException("bucketConfig"); if (BucketConfig == null || !BucketConfig.Nodes.AreEqual<Node>(bucketConfig.Nodes) || force) { var clientBucketConfig = ClientConfig.BucketConfigs[bucketConfig.Name]; var servers = new Dictionary<IPAddress, IServer>(); var nodes = bucketConfig.GetNodes(); foreach (var adapter in nodes) { var endpoint = adapter.GetIPEndPoint(clientBucketConfig.UseSsl); try { var connectionPool = ConnectionPoolFactory(clientBucketConfig.PoolConfiguration, endpoint); var ioStrategy = IOStrategyFactory(connectionPool); var server = new Core.Server(ioStrategy, adapter, ClientConfig, bucketConfig, Transcoder) { SaslFactory = SaslFactory }; server.CreateSaslMechanismIfNotExists(); servers.Add(endpoint.Address, server); } catch (Exception e) { Log.ErrorFormat("Could not add server {0}. Exception: {1}", endpoint, e); } } //If servers is empty that means we could not initialize _any_ nodes //We fail-fast here so that the problem can be indentified and handled. if (!servers.Any()) { throw new CouchbaseBootstrapException(ExceptionUtil.BootStrapFailedMsg); } var newDataNodes = servers .Where(x => x.Value.IsDataNode) .Select(x => x.Value) .ToList(); Interlocked.Exchange(ref DataNodes, newDataNodes); IsDataCapable = newDataNodes.Count > 0; var old = Interlocked.Exchange(ref Servers, servers); if (old != null) { foreach (var server in old.Values) { server.Dispose(); } old.Clear(); } } Interlocked.Exchange(ref KeyMapper, new KetamaKeyMapper(Servers)); Interlocked.Exchange(ref _bucketConfig, bucketConfig); }
/// <summary> /// transform a dictionary into the query string that is translated in byte array then /// </summary> /// <param name="items"></param> /// <returns></returns> public static byte[] PostBytes(Dictionary<string, string> items) { if (items == null || !items.Any()) return null; var bytes = Encoding.UTF8.GetBytes(items.ToQueryString()); return bytes.Any() ? bytes : null; }
public IBuildResponse Begin( HttpStatus status, Action<IDefineHeaders> headers ) { var responseHeaders = new Dictionary<string,string>(); var headerDefinition = new HeaderBuilder( responseHeaders ); headers( headerDefinition ); ChunkResponse = responseHeaders.Any( x => x.Key == HttpHeader.TRANSFER_ENCODING && x.Value.Equals( "chunked" )); Respond( status.ToString(), responseHeaders, Setup ); return this; }
private void SetupFacets <T, TU>(EsRootObjectBase <T> results, SearchResultBase <TU> searchResult) { Dictionary <string, Aggregation> facets = results.Aggregations; if (facets?.Any() == true) { searchResult.Facets = facets.Select(f => new FacetEntry { Key = f.Key, Count = f.Value.Facets.Length, Hits = f.Value.Facets.Select(i => new FacetHit { Key = i.Key, Count = i.Count }).ToArray() }).ToArray(); } }
private string GetParametersString(Dictionary <string, string> parameters) { if (parameters?.Any() != true) { return(string.Empty); } var parametersString = new StringBuilder("?"); foreach (var parameter in parameters) { parametersString.Append($"{parameter.Key}={parameter.Value}&"); } parametersString.Remove(parametersString.Length - 1, 1); return(parametersString.ToString()); }
protected async Task <bool> Delete(string path, Dictionary <string, string> parameters = null) { if (parameters?.Any() ?? false) { path += "?" + string.Join("&", parameters.Select(kvp => $"{HttpUtility.UrlEncode(kvp.Key)}={HttpUtility.UrlEncode(kvp.Value)}")); } try { var response = await _client.DeleteAsync(path); return(response.IsSuccessStatusCode); } catch (HttpRequestException) { return(default);
/// <summary> /// Overrides INI file parameters. /// </summary> /// <param name="iniMap"> /// The INI map. /// </param> /// <param name="path"> /// The INI file path. /// </param> public static void Overrides(Dictionary <string, Dictionary <string, string> > iniMap, string path) { if (iniMap?.Any() != true) { return; } var file = PathEx.Combine(path); try { if (!PathEx.IsValidPath(file)) { throw new NotSupportedException(); } var dir = Path.GetDirectoryName(file); if (string.IsNullOrEmpty(dir)) { throw new ArgumentNullException(dir); } if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } if (!File.Exists(file)) { File.Create(file).Close(); } } catch (Exception ex) { Log.Write(ex); return; } foreach (var data in iniMap) { var section = data.Key; foreach (var pair in iniMap[section]) { var key = pair.Key; var value = pair.Value; Ini.WriteDirect(section, key, value, path); } } }
public override void Convert(Stream input, IResultLogWriter output, LoggingOptions loggingOptions) { input = input ?? throw new ArgumentNullException(nameof(input)); output = output ?? throw new ArgumentNullException(nameof(output)); output.Initialize(id: null, automationId: null); var tool = new Tool { Name = ToolFormat.PREfast, FullName = "PREfast Code Analysis" }; output.WriteTool(tool); XmlReaderSettings settings = new XmlReaderSettings { XmlResolver = null }; var serializer = new XmlSerializer(typeof(DefectList)); using (var reader = XmlReader.Create(input, settings)) { var defectList = (DefectList)serializer.Deserialize(reader); var results = new List <Result>(); foreach (Defect entry in defectList.Defects) { results.Add(CreateResult(entry)); } var fileInfoFactory = new FileInfoFactory(MimeType.DetermineFromFileExtension, loggingOptions); Dictionary <string, FileData> fileDictionary = fileInfoFactory.Create(results); if (fileDictionary?.Any() == true) { output.WriteFiles(fileDictionary); } output.OpenResults(); output.WriteResults(results); output.CloseResults(); } }
/// <summary> /// Adds a mapping of custom extension values against custom attribute values for a given element to the provided /// extensions object. /// </summary> /// <param name="extensions">The target extensions object in which the mapped extensions and custom attribute /// values will be added to.</param> /// <param name="context">The OData context.</param> /// <param name="element">The target element.</param> internal static void AddCustomAtributesToExtensions(this IDictionary <string, IOpenApiExtension> extensions, ODataContext context, IEdmElement element) { if (extensions == null || context == null || element == null) { return; } Dictionary <string, string> atrributesValueMap = GetCustomXMLAtrributesValueMapping(context.Model, element, context.Settings.CustomXMLAttributesMapping); if (atrributesValueMap?.Any() ?? false) { foreach (var item in atrributesValueMap) { extensions.TryAdd(item.Key, new OpenApiString(item.Value)); } } }
private nac.CurlThin.SafeHandles.SafeSlistHandle curlSetHeader(CurlHandleType curlHandle, Dictionary <string, string> headers) { // followed documentation here: https://curl.se/libcurl/c/CURLOPT_HTTPHEADER.html if (headers?.Any() == true) { nac.CurlThin.SafeHandles.SafeSlistHandle list = SafeSlistHandle.Null; foreach (var pair in headers) { list = nac.CurlThin.CurlNative.Slist.Append(list, $"{pair.Key}: {pair.Value}"); } curl.SetOpt(curlHandle, CURLoption.HTTPHEADER, list.DangerousGetHandle()); return(list); // list will need to be freed } return(null); }
public static void PrintFormatted(Dictionary <string, Formatter> textAndFormats, Color fallbackColor, ConsoleWriteMethod writeMethod) { if (textAndFormats?.Any() ?? false) { foreach (var(text, format) in textAndFormats) { switch (writeMethod) { case ConsoleWriteMethod.Write: ColorfulConsole.WriteFormatted(text, fallbackColor, format); break; case ConsoleWriteMethod.WriteLine: default: ColorfulConsole.WriteLineFormatted(text, fallbackColor, format); break; } } } }
public static EmailBodyModel CreateBodyHtmlTemplate(string bodyHtmlTemplatePath, BodyTemplateName bodyTemplateName, Dictionary <string, string> bodyHtmlTemplateValues = null) { Utils.IsNullOrEmptyThrowException(bodyHtmlTemplatePath, nameof(bodyHtmlTemplatePath)); var filePath = Path.Combine(bodyHtmlTemplatePath, bodyTemplateName.Value); Utils.IsFileExistsThrowException(filePath); var template = new StreamReader(filePath).ReadToEnd(); if (bodyHtmlTemplateValues?.Any() == true) { foreach (var item in bodyHtmlTemplateValues) { template = template.Replace(item.Key, item.Value); } } return(new EmailBodyModel(template)); }
public void Apply(ApplicationModel application) { if (_kvps?.Any() != true) { return; } var camelCased = _kvps.Select(kvp => new KeyValuePair <string, string>(kvp.Key.ToCamelCase(), kvp.Value.ToCamelCase()) ).ToList(); // Build a list of ALL selectors, and fix up tokens. var anonObjects = application.Controllers.Select(cm => new { cm.ControllerName, selectors = cm.Selectors.Where(sm => sm.AttributeRouteModel is not null) .Concat(cm.Actions.SelectMany(am => am.Selectors.Where(sm => sm.AttributeRouteModel is not null) ) ) }
private static string GetEndpoint(string uri, Dictionary <string, string> parameters) { StringBuilder builder = new StringBuilder(); if (parameters?.Any() == true) { foreach (var parameter in parameters) { if (builder.Length == 0) { builder.Append($"?{parameter.Key}={parameter.Value}"); } else { builder.Append($"&{parameter.Key}={parameter.Value}"); } } } return($"{uri}{builder}"); }
IEnumerable <PropertyValue> FormatExtensions(Dictionary <string, SslExtension> extensions) { if (extensions?.Any() == false) { yield break; } var label = "Extensions"; var values = extensions.Values.OrderBy(x => x.Position).ToArray(); var names = values.Select(x => $"0x{x.Type:X4} ({x.Name})").ToArray(); var len = names.Max(x => x.Length); for (int i = 0; i < values.Length; i++) { var name = names[i]; yield return(Create(label, $"{name}{new string(' ', len - name.Length)}: {GetHex(values[i].RawData)}")); label = ""; } }
private string BuildUpsertQuery(string[] keys, string table, bool insertKeys, object args, Dictionary <string, string> onUpdateArgs = null, Dictionary <string, string> onInsertArgs = null) { if (_connection is not SqlConnection) { throw new InvalidOperationException("Merge is not supported for the current connection"); } var type = args.GetType(); return(_upsertCache.GetOrAdd($"{table}:{type.FullName}", _ => { var props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance).Select(x => x.Name).ToList(); var argValues = string.Join(", ", props.Select(x => "@" + x)); var condition = keys.Select(k => $"Target.[{k}] = Source.[{k}]").Aggregate((x, y) => $"{x} AND {y}"); var columns = (insertKeys ? props : props.Except(keys)).Select(x => $"[{x}]").ToList(); var update = string.Join(", ", columns.Select(c => $"{c} = Source.{c}")); var sourceColumns = string.Join(", ", columns.Select(c => $"Source.{c}")); var onUpdate = onUpdateArgs?.Any() ?? false ? "," + string.Join(", ", onUpdateArgs.Select(x => $"[{x.Key}] = {x.Value}")) : ""; var onInsertColumns = onInsertArgs?.Any() ?? false ? "," + string.Join(", ", onInsertArgs.Select(x => $"[{x.Key}]")) : ""; var onInsertValues = onInsertArgs?.Any() ?? false ? "," + string.Join(", ", onInsertArgs.Select(x => $"{x.Value}")) : ""; var columnString = string.Join(",", columns); var sql = $@" MERGE {table} AS Target USING ( VALUES ({argValues})) AS Source ({string.Join(",", props.Select(x => $"[{x}]"))}) ON {condition} WHEN MATCHED THEN UPDATE SET {update}{onUpdate} WHEN NOT MATCHED BY TARGET THEN INSERT ({columnString}{onInsertColumns}) VALUES ( {sourceColumns}{onInsertValues}) OUTPUT INSERTED.*;"; return sql; })); }
public async Task RunJobAsync(string job, Dictionary <string, string> args = null, string cause = "Run through DiscordBot JenkinsService") { var endpoint = "build"; var argString = ""; if (args?.Any() ?? false) { endpoint = "buildWithParameters"; argString = "&" + string.Join("&", args.Select(kvp => $"{kvp.Key}={HttpUtility.UrlEncode(kvp.Value)}")); } var uri = $"{JENKINS_URL}/buildByToken/{endpoint}?job={HttpUtility.UrlEncode(job)}&token={_token}{argString}"; if (!string.IsNullOrWhiteSpace(cause)) { uri += $"&cause={HttpUtility.UrlEncode(cause)}"; } var resp = await _http.GetAsync(uri); resp.EnsureSuccessStatusCode(); }
public override void Convert(Stream input, IResultLogWriter output, OptionallyEmittedData dataToInsert) { input = input ?? throw new ArgumentNullException(nameof(input)); output = output ?? throw new ArgumentNullException(nameof(output)); TSLintLog tsLintLog = logReader.ReadLog(input); Tool tool = new Tool { Name = "TSLint" }; var run = new Run() { Tool = tool }; output.Initialize(run); var results = new List <Result>(); foreach (TSLintLogEntry entry in tsLintLog) { results.Add(CreateResult(entry)); } var fileInfoFactory = new FileInfoFactory(MimeType.DetermineFromFileExtension, dataToInsert); Dictionary <string, FileData> fileDictionary = fileInfoFactory.Create(results); if (fileDictionary?.Any() == true) { output.WriteFiles(fileDictionary); } output.OpenResults(); output.WriteResults(results); output.CloseResults(); }
public static void FileSecureForwarding(Options option, Dictionary <string, string> fileMap) { if (fileMap?.Any() != true) { return; } foreach (var data in fileMap) { if (string.IsNullOrWhiteSpace(data.Key) || string.IsNullOrWhiteSpace(data.Value)) { continue; } var srcPath = PathEx.Combine(data.Key); var destPath = PathEx.Combine(data.Value); if (!File.Exists(srcPath) || !PathEx.IsValidPath(srcPath) || !PathEx.IsValidPath(destPath)) { continue; } switch (option) { case Options.Exit: using (var p = ProcessEx.Send($"DEL /F /Q \"{destPath}\"", Elevation.IsAdministrator, false)) if (p?.HasExited == false) { p.WaitForExit(); } break; default: using (var p = ProcessEx.Send($"COPY /Y \"{srcPath}\" \"{destPath}\"", Elevation.IsAdministrator, false)) if (p?.HasExited == false) { p.WaitForExit(); } break; } } }
public void UnbindToServiceType() { #region OnClientConnect Method if (OnClientConnectMethod != null) { Core.Log.LibDebug("Unbinding OnClientConnectMethod in the service {0}", Descriptor.Name); } OnClientConnectMethod = null; #endregion #region Events if (ServiceEventHandlers?.Any() != true) { return; } foreach (var ev in ServiceEventHandlers) { Core.Log.LibDebug("Unbinding Event: {0} on service {1}", ev.Key.Name, Descriptor.Name); ev.Key.RemoveEventHandler(ServiceInstance, ev.Value); } ServiceEventHandlers.Clear(); #endregion }
public void Dispose() { try { if (_toDispose?.Any() ?? false) { foreach (var toDispose in _toDispose) { try { toDispose.Value.Dispose(); } catch { } } } } catch { //intentional;disposing } }
/// <summary> /// Initialises the Test Logger with given parameters. /// </summary> /// <param name="events">Events that can be registered for.</param> /// <param name="parameters">Collection of parameters.</param> public void Initialize(TestLoggerEvents events, Dictionary <string, string> parameters) { if (events is null) { throw new ArgumentNullException(nameof(events)); } if (parameters?.Any() != true) { throw new ArgumentNullException(nameof(parameters)); } if (parameters.ContainsKey(Constants.LogFilePrefixKey) && parameters.ContainsKey(Constants.LogFileNameKey)) { throw new ArgumentException($"The parameters {Constants.LogFileNameKey} and {Constants.LogFilePrefixKey} cannot be used together."); } var testRunDirectory = parameters[DefaultLoggerParameterNames.TestRunDirectory]; TestParameters = parameters; Initialize(events, testRunDirectory); OnInitialize(TestParameters); }
/// <summary> /// Génère le script SQL d'initialisation des listes reference. /// </summary> /// <param name="initDictionary">Dictionnaire des initialisations.</param> /// <param name="isStatic">True if generation for static list.</param> public void GenerateListInitScript(Dictionary <ModelClass, TableInit> initDictionary, bool isStatic) { var outputFileName = isStatic ? _parameters.StaticListFile : _parameters.ReferenceListFile; if (outputFileName == null) { if (initDictionary?.Any() ?? false) { throw new ArgumentNullException(isStatic ? "StaticListFile" : "ReferenceListFile"); } else { return; } } Console.WriteLine("Generating init script " + outputFileName); DeleteFileIfExists(outputFileName); using (var writerInsert = File.CreateText(outputFileName)) { writerInsert.WriteLine("-- =========================================================================================== "); writerInsert.WriteLine($"-- Application Name : {_appName} "); writerInsert.WriteLine("-- Script Name : "+ outputFileName); writerInsert.WriteLine("-- Description : Script d'insertion des données de références"+ (!isStatic ? " non " : " ") + "statiques. "); writerInsert.WriteLine("-- ==========================================================================================="); if (initDictionary != null) { var orderList = OrderStaticTableList(initDictionary); foreach (ModelClass modelClass in orderList) { WriteInsert(writerInsert, initDictionary[modelClass], modelClass, isStatic); } } } }
private Uri CreateApiUrl(string requestPath, Dictionary <string, object> queryParams = null) { var builder = new UriBuilder($"{BaseUrl}/{requestPath}"); if (queryParams?.Any() == true) { var keyValues = new List <string>(); foreach (var queryParam in queryParams) { var keyValue = $"{queryParam.Key}="; if (queryParam.Value != null) { keyValue += Uri.EscapeDataString(queryParam.Value.ToString()); } keyValues.Add(keyValue); } builder.Query = string.Join("&", keyValues.ToArray()); } var uriString = builder.ToString(); var uri = new Uri(uriString); return(uri); }
/// <summary> /// Get an adaptive card attachment with given content. It takes a Dictionary<string, string>. /// For each KeyValuePair in the dictionary, we'll replace "{key}" with "value" in the json string. /// </summary> /// <param name="args">content to be put into the card</param> /// <returns>formatted adaptive card attachment with proper values injected</returns> public Attachment GetAttachment(Dictionary <string, string> values = null) { var formattedCard = this.jsonContent; if (values?.Any() == true) { // Format the objects into the card var sb = new StringBuilder(formattedCard); foreach (var kvp in values) { // Replace {name} with value sb.Replace($"{{{kvp.Key}}}", HttpUtility.JavaScriptStringEncode(kvp.Value)); } formattedCard = sb.ToString(); } // Construct attachment object return(new Attachment() { ContentType = "application/vnd.microsoft.card.adaptive", Content = JsonConvert.DeserializeObject <AdaptiveCard>(formattedCard), }); }
private static string GetMappedColumnName(MemberInfo member, Dictionary <string, string> columnMappings) { if (member == null) { return(null); } var attrib = (DapperColumnAttribute)Attribute.GetCustomAttribute(member, typeof(DapperColumnAttribute), false); if (attrib != null) { return(attrib.Name); } string mappedPropName = null; if (columnMappings?.Any() == true && columnMappings.TryGetValue(member.Name, out mappedPropName)) { return(mappedPropName); } return(null); }
protected override void ReadObjectProperties(JsonReader reader, DynamicObject result, Dictionary <string, Property> properties, JsonSerializer serializer) { reader.Advance(); TypeInfo?typeInfo = null; void SetResult(IEnumerable <DynamicProperty>?properties = null) { reader.AssertEndObject(); result.Type = typeInfo; if (properties?.Any() == true) { result.Properties = new PropertySet(properties); } } if (reader.IsProperty(nameof(DynamicObject.Type))) { typeInfo = reader.Read <TypeInfo?>(serializer); reader.Advance(); } if (reader.IsProperty("Value")) { var value = reader.Read(typeInfo, serializer); SetResult(new[] { new DynamicProperty(string.Empty, value) }); return; } if (reader.IsProperty("Values")) { reader.Advance(); if (reader.TokenType == JsonToken.Null) { SetResult(); return; } if (reader.TokenType != JsonToken.StartArray) { throw reader.CreateException($"Expected array"); } var elementType = TypeHelper.GetElementType(typeInfo?.Type) ?? typeof(object); bool TryReadNextItem(out object?value) { if (!reader.TryRead(elementType, serializer, out value)) { // TODO: is max length quota required? if (reader.TokenType == JsonToken.EndArray) { return(false); } throw reader.CreateException("Unexpected token structure."); } return(true); } var values = new List <object?>(); while (TryReadNextItem(out var item)) { values.Add(item); } if (values.Any(x => x != null && (elementType == typeof(object) || !elementType.IsAssignableFrom(x.GetType()))) && values.All(x => x is null || x is string)) { elementType = typeof(string); } var valueArray = CastCollectionToArrayOfType(elementType, values); SetResult(new[] { new DynamicProperty(string.Empty, valueArray) }); return; } if (reader.IsProperty(nameof(DynamicObject.Properties))) { reader.Advance(); if (reader.TokenType == JsonToken.Null) { SetResult(); return; } if (reader.TokenType != JsonToken.StartArray) { throw reader.CreateException("Expected array"); } var propertySet = new List <DynamicProperty>(); bool NextItem() { // TODO: is max length quota required? reader.Advance(); return(reader.TokenType != JsonToken.EndArray); } while (NextItem()) { reader.AssertStartObject(false); reader.AssertProperty(nameof(DynamicProperty.Name)); var name = reader.ReadAsString() ?? throw reader.CreateException("Property name must not be null"); reader.AssertProperty(nameof(Type)); var type = reader.Read <TypeInfo?>(serializer); reader.AssertProperty(nameof(DynamicProperty.Value)); var value = reader.Read(type, serializer); reader.AssertEndObject(); propertySet.Add(new DynamicProperty(name, value)); } SetResult(propertySet); return; } throw reader.CreateException($"Unexpected token {reader.TokenType}"); }
/// <summary> /// Takes a screenshot of a web page. /// </summary> /// <param name="url">The URL of the web page to screenshoot.</param> /// <param name="filePath">The image file to save to.</param> /// <param name="width">The device width of the browser</param> /// <returns>The full file path of the saved image</returns> public NavigationTiming TakeScreenshot(string url, string filePath, int?width = null) { var outputDir = Path.GetDirectoryName(filePath); Directory.CreateDirectory(outputDir); _driver.Navigate().GoToUrl(url); ResizeWindow(); if (_options.HighlightBrokenLinks) { HighlightBrokenLinks(url); } // Sometimes, when this isn't high enough, the performance timings return incomplete data. int screenshotDelay = 3000; Thread.Sleep(screenshotDelay); var requestStats = GetRequestStats(); var screenshot = _driver.GetScreenshot(); screenshot.SaveAsFile(filePath, _imageFormat); ClearResize(); return(requestStats); // LOCAL FUNCTIONS NavigationTiming GetRequestStats() { try { var stats = (string)_driver.ExecuteScript( @"return (window && window.performance && JSON.stringify([...window.performance.getEntriesByType('navigation'),{ }][0])) || '{}'"); var deprecatedTiming = (string)_driver.ExecuteScript( @"return (window && window.performance && window.performance.timing && JSON.stringify(window.performance.timing)) || '{}'"); Logger.Default.Log($"Stats for {url}..."); Logger.Default.Log(stats); Logger.Default.Log(deprecatedTiming); string ConvertToInt(Match m) { var origValue = m.Value; if (!double.TryParse(origValue, out var dblVal)) { return(origValue); } var intValue = (int)Math.Round(dblVal); return(intValue.ToString()); } stats = Regex.Replace(stats, @"\d+\.\d+", ConvertToInt); Logger.Default.Log("stats converted to int: " + stats); return(JsonConvert.DeserializeObject <NavigationTiming>((string)stats)); } catch (Exception ex) { Debug.WriteLine("Error parsing request timings: " + ex.Message); return(new NavigationTiming()); } } /// <summary> /// Repeatedly resize the window to account for lazily loaded elements. /// </summary> /// <param name="width"></param> void ResizeWindow() { // Adapted from https://stackoverflow.com/a/56535317 int numTries = 0; const int maxTries = 8; int prevHeight; int calculatedHeight = -1; string autoWidthCommand = @"return Math.max( window.innerWidth, document.body.scrollWidth, document.documentElement.scrollWidth)"; // Repeatedly resize height to allow new elements to (lazily) load. do { prevHeight = calculatedHeight; var calculatedWidth = width.HasValue ? $"return {width}" : autoWidthCommand; calculatedHeight = CalculateDocHeight(); // TODO: Set device-specific user agents. Dictionary <string, object> metrics = new Dictionary <string, object> { ["width"] = _driver.ExecuteScript(calculatedWidth), ["height"] = calculatedHeight, ["deviceScaleFactor"] = ScaleFactor(false), ["mobile"] = _driver.ExecuteScript("return typeof window.orientation !== 'undefined'") }; _driver.ExecuteChromeCommand("Emulation.setDeviceMetricsOverride", metrics); } while (calculatedHeight != prevHeight && ++numTries < maxTries); // LOCAL FUNCTIONS int CalculateDocHeight() { // Sometimes a long, sometimes double, etc object jsHeight = _driver.ExecuteScript( @"return Math.max( document.body.scrollHeight, document.body.offsetHeight, document.documentElement.clientHeight, document.documentElement.scrollHeight, document.documentElement.offsetHeight, document.documentElement.getBoundingClientRect().height)"); double numericHeight = Convert.ToDouble(jsHeight); return((int)Math.Ceiling(numericHeight)); } // False for a 1:1 pixel ratio with the image // True for an easier-to-read image on the current monitor. double ScaleFactor(bool shouldScaleImage) => shouldScaleImage ? (double)_driver.ExecuteScript("return window.devicePixelRatio") : 1.0; } void ClearResize() { try { _driver.ExecuteChromeCommand("Emulation.clearDeviceMetricsOverride", new Dictionary <string, object>()); } catch (Exception ex) { // Usually thrown when the driver or browser window is closed. if (!(ex is WebDriverException || ex is NoSuchWindowException)) { throw; } } } void HighlightBrokenLinks(string rawCallingUri) { var standardizedUri = new Uri(rawCallingUri); standardizedUri = standardizedUri.TryStandardize(); if (_brokenLinks?.Any() != true) { return; } var selectors = _brokenLinks .SelectMany(l => l.Value.Sources) .Where(x => standardizedUri.Equals(x.CallingPage)) .Select(x => $@"a[href='{x.Href}']"); var combinedSelector = string.Join(",", selectors); var styles = $@" {combinedSelector} {{ border: 3px dashed red; }}"; var script = $@" var style = document.createElement('style'); style.type = 'text/css'; style.innerHTML = `{styles}`; document.getElementsByTagName('head')[0].appendChild(style);"; _driver.ExecuteScript(script); } }
/// <summary> /// 获取或创建架构属性信息 /// </summary> /// <param name="type"></param> /// <param name="innerModel">处理内部模型</param> /// <param name="exceptionProperties">特别输出的属性</param> /// <param name="ignoreProperties">特别忽略的属性</param> /// <remarks>如果在特别输出参数和特别忽略参数中同时指定了同一个属性,那么最终不会输出该属性</remarks> /// <returns></returns> public static Dictionary <string, List <string> > GetOrNullForPropertyDic(this Type type, bool innerModel = true, Dictionary <string, List <string> > exceptionProperties = null, Dictionary <string, List <string> > ignoreProperties = null) { var propertyDic = type.GetPropertysOfTypeDic(exceptionProperties?.Any() == true && ignoreProperties?.Any() == true); if (propertyDic.Any()) { goto end; } type.FilterModel((_type, prop) => { if (!propertyDic.ContainsKey(_type.FullName)) { propertyDic.Add(_type.FullName, new List <string>() { prop.Name }); } else { propertyDic[_type.FullName].Add(prop.Name); } if (!CacheExtention.AssemblyOfTypeDic.ContainsKey(_type.FullName)) { CacheExtention.AssemblyOfTypeDic.AddOrUpdate(_type.FullName, _type.Assembly.FullName, (key, old) => _type.Assembly.FullName); } }, null, innerModel); type.SetPropertysOfTypeDic(propertyDic); end: if (exceptionProperties != null) { foreach (var item in exceptionProperties) { if (!propertyDic.ContainsKey(item.Key)) { propertyDic.Add(item.Key, item.Value); } else { propertyDic[item.Key] = propertyDic[item.Key].Union(item.Value).ToList(); } } } if (ignoreProperties != null) { foreach (var item in ignoreProperties) { if (propertyDic.ContainsKey(item.Key)) { propertyDic[item.Key] = propertyDic[item.Key].Except(item.Value).ToList(); } } } return(propertyDic); }
public RequestResult RunRequest(string resource, string requestMethod, object body = null, int?timeout = null, Dictionary <string, object> formParameters = null) { try { var requestUrl = ZendeskUrl + resource; var req = WebRequest.Create(requestUrl) as HttpWebRequest; if (Proxy != null) { req.Proxy = Proxy; } req.Headers["Authorization"] = GetPasswordOrTokenAuthHeader(); req.PreAuthenticate = true; req.Method = requestMethod; //GET POST PUT DELETE req.Accept = "application/json, application/xml, text/json, text/x-json, text/javascript, text/xml"; req.Timeout = 120000; //?? req.Timeout; byte[] data = null; if (formParameters?.Any() ?? false) { data = GetFromData(req, formParameters); } else if (body is ZenFile zenFile) { req.ContentType = zenFile.ContentType; data = zenFile.FileData; } else if (body != null) { req.ContentType = "application/json"; data = encoding.GetBytes(JsonConvert.SerializeObject(body, jsonSettings)); } if (data != null) { req.ContentLength = data.Length; using (var dataStream = req.GetRequestStream()) { dataStream.Write(data, 0, data.Length); } } var res = req.GetResponse(); var response = res as HttpWebResponse; var responseFromServer = string.Empty; using (var responseStream = response.GetResponseStream()) { using (var reader = new StreamReader(responseStream)) { responseFromServer = reader.ReadToEnd(); } } return(new RequestResult { Content = responseFromServer, HttpStatusCode = response.StatusCode }); } catch (WebException ex) { var wException = GetWebException(resource, body, ex); throw wException; } }
internal async static Task <(IEnumerable <IKubernetesResource>, IDictionary <string, string>)> GetFunctionsDeploymentResources( string name, string imageName, string @namespace, TriggersPayload triggers, IDictionary <string, string> secrets, string pullSecret = null, string secretsCollectionName = null, string configMapName = null, bool useConfigMap = false, int?pollingInterval = null, int?cooldownPeriod = null, string serviceType = "LoadBalancer", int?minReplicas = null, int?maxReplicas = null, string keysSecretCollectionName = null, bool mountKeysAsContainerVolume = false) { ScaledObjectV1Alpha1 scaledobject = null; var result = new List <IKubernetesResource>(); var deployments = new List <DeploymentV1Apps>(); var httpFunctions = triggers.FunctionsJson .Where(b => b.Value["bindings"]?.Any(e => e?["type"].ToString().IndexOf("httpTrigger", StringComparison.OrdinalIgnoreCase) != -1) == true); var nonHttpFunctions = triggers.FunctionsJson.Where(f => httpFunctions.All(h => h.Key != f.Key)); keysSecretCollectionName = string.IsNullOrEmpty(keysSecretCollectionName) ? $"func-keys-kube-secret-{name}" : keysSecretCollectionName; if (httpFunctions.Any()) { int position = 0; var enabledFunctions = httpFunctions.ToDictionary(k => $"AzureFunctionsJobHost__functions__{position++}", v => v.Key); //Environment variables for the func app keys kubernetes secret var kubernetesSecretEnvironmentVariable = FuncAppKeysHelper.FuncKeysKubernetesEnvironVariables(keysSecretCollectionName, mountKeysAsContainerVolume); var additionalEnvVars = enabledFunctions.Concat(kubernetesSecretEnvironmentVariable).ToDictionary(kvp => kvp.Key, kvp => kvp.Value); var deployment = GetDeployment(name + "-http", @namespace, imageName, pullSecret, 1, additionalEnvVars, port: 80); deployments.Add(deployment); var service = GetService(name + "-http", @namespace, deployment, serviceType); result.Add(service); } if (nonHttpFunctions.Any()) { int position = 0; var enabledFunctions = nonHttpFunctions.ToDictionary(k => $"AzureFunctionsJobHost__functions__{position++}", v => v.Key); var deployment = GetDeployment(name, @namespace, imageName, pullSecret, minReplicas ?? 0, enabledFunctions); deployments.Add(deployment); scaledobject = GetScaledObject(name, @namespace, triggers, deployment, pollingInterval, cooldownPeriod, minReplicas, maxReplicas); } // Set worker runtime if needed. if (!secrets.ContainsKey(Constants.FunctionsWorkerRuntime)) { secrets[Constants.FunctionsWorkerRuntime] = GlobalCoreToolsSettings.CurrentWorkerRuntime.ToString(); } int resourceIndex = 0; if (useConfigMap) { var configMap = GetConfigMap(name, @namespace, secrets); result.Insert(resourceIndex, configMap); resourceIndex++; foreach (var deployment in deployments) { deployment.Spec.Template.Spec.Containers.First().EnvFrom = new ContainerEnvironmentFromV1[] { new ContainerEnvironmentFromV1 { ConfigMapRef = new NamedObjectV1 { Name = configMap.Metadata.Name } } }; } } else if (!string.IsNullOrEmpty(secretsCollectionName)) { foreach (var deployment in deployments) { deployment.Spec.Template.Spec.Containers.First().EnvFrom = new ContainerEnvironmentFromV1[] { new ContainerEnvironmentFromV1 { SecretRef = new NamedObjectV1 { Name = secretsCollectionName } } }; } } else if (!string.IsNullOrEmpty(configMapName)) { foreach (var deployment in deployments) { deployment.Spec.Template.Spec.Containers.First().EnvFrom = new ContainerEnvironmentFromV1[] { new ContainerEnvironmentFromV1 { ConfigMapRef = new NamedObjectV1 { Name = configMapName } } }; } } else { var secret = GetSecret(name, @namespace, secrets); result.Insert(resourceIndex, secret); resourceIndex++; foreach (var deployment in deployments) { deployment.Spec.Template.Spec.Containers.First().EnvFrom = new ContainerEnvironmentFromV1[] { new ContainerEnvironmentFromV1 { SecretRef = new NamedObjectV1 { Name = secret.Metadata.Name } } }; } } IDictionary <string, string> resultantFunctionKeys = new Dictionary <string, string>(); if (httpFunctions.Any()) { var currentImageFuncKeys = FuncAppKeysHelper.CreateKeys(httpFunctions.Select(f => f.Key)); resultantFunctionKeys = GetFunctionKeys(currentImageFuncKeys, await GetExistingFunctionKeys(keysSecretCollectionName, @namespace)); if (resultantFunctionKeys?.Any() == true) { result.Insert(resourceIndex, GetSecret(keysSecretCollectionName, @namespace, resultantFunctionKeys)); resourceIndex++; } //if function keys Secrets needs to be mounted as volume in the function runtime container if (mountKeysAsContainerVolume) { FuncAppKeysHelper.CreateFuncAppKeysVolumeMountDeploymentResource(deployments, keysSecretCollectionName); } //Create the Pod identity with the role to modify the function kubernetes secret else { var svcActName = $"{name}-function-keys-identity-svc-act"; var svcActDeploymentResource = GetServiceAccount(svcActName, @namespace); result.Insert(resourceIndex, svcActDeploymentResource); resourceIndex++; var funcKeysManagerRoleName = "functions-keys-manager-role"; var secretManagerRole = GetSecretManagerRole(funcKeysManagerRoleName, @namespace); result.Insert(resourceIndex, secretManagerRole); resourceIndex++; var roleBindingName = $"{svcActName}-functions-keys-manager-rolebinding"; var funcKeysRoleBindingDeploymentResource = GetRoleBinding(roleBindingName, @namespace, funcKeysManagerRoleName, svcActName); result.Insert(resourceIndex, funcKeysRoleBindingDeploymentResource); resourceIndex++; //add service account identity to the pod foreach (var deployment in deployments) { deployment.Spec.Template.Spec.ServiceAccountName = svcActName; } } } result = result.Concat(deployments).ToList(); return(scaledobject != null ? result.Append(scaledobject) : result, resultantFunctionKeys); }
//public void AddApiFileParameter(Dictionary<string, object> multipartData, string filePath, int pictureId) //{ // var count = 0; // var paths = filePath.Contains(";") ? filePath.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList() : new List<string> { filePath }; // foreach (var path in paths) // { // using (var fstream = new FileStream(path, FileMode.Open, FileAccess.Read)) // { // byte[] data = new byte[fstream.Length]; // fstream.Read(data, 0, data.Length); // var name = Path.GetFileName(path); // var id = string.Format("my-file-{0}", ++count); // var apiFile = new ApiFileParameter(data, name, MimeMapping.GetMimeMapping(name)); // if (pictureId != 0) // { // apiFile.Parameters.Add("PictureId", pictureId.ToString()); // } // // Test pass through of custom parameters // apiFile.Parameters.Add("CustomValue1", string.Format("{0:N}", Guid.NewGuid())); // apiFile.Parameters.Add("CustomValue2", string.Format("say hello to {0}", id)); // multipartData.Add(id, apiFile); // fstream.Close(); // } // } //} public HttpWebRequest StartRequest(WebApiRequestContext context, string content, Dictionary <string, object> multipartData, out StringBuilder requestContent) { requestContent = new StringBuilder(); if (context == null || !context.IsValid) { return(null); } // Client system time must not be too far away from APPI server time! Check response header. // ISO-8601 utc timestamp with milliseconds (e.g. 2013-09-23T09:24:43.5395441Z). string timestamp = DateTime.UtcNow.ToString("o"); byte[] data = null; var contentMd5Hash = string.Empty; var request = (HttpWebRequest)WebRequest.Create(context.Url); SetTimeout(request); // Optional. request.UserAgent = Program.ConsumerName; request.Method = context.HttpMethod; request.Headers.Add(HttpRequestHeader.Pragma, "no-cache"); request.Headers.Add(HttpRequestHeader.CacheControl, "no-cache, no-store"); request.Accept = context.HttpAcceptType; request.Headers.Add(HttpRequestHeader.AcceptCharset, "UTF-8"); request.Headers.Add(WebApiGlobal.HeaderName.PublicKey, context.PublicKey); request.Headers.Add(WebApiGlobal.HeaderName.Date, timestamp); // Additional headers. if (context.AdditionalHeaders.HasValue()) { var jsonHeaders = JObject.Parse(context.AdditionalHeaders); foreach (var item in jsonHeaders) { var value = item.Value?.ToString(); if (item.Key.HasValue() && value.HasValue()) { request.Headers.Add(item.Key, value); } } } if (BodySupported(context.HttpMethod)) { if (MultipartSupported(context.HttpMethod) && (multipartData?.Any() ?? false)) { var formDataBoundary = string.Format("----------{0:N}", Guid.NewGuid()); data = GetMultipartFormData(multipartData, formDataBoundary, requestContent); contentMd5Hash = CreateContentMd5Hash(data); request.ContentLength = data.Length; request.ContentType = "multipart/form-data; boundary=" + formDataBoundary; } else if (!string.IsNullOrWhiteSpace(content)) { requestContent.Append(content); data = Encoding.UTF8.GetBytes(content); contentMd5Hash = CreateContentMd5Hash(data); request.ContentLength = data.Length; request.ContentType = "application/json; charset=utf-8"; } else { request.ContentLength = 0; } } if (!string.IsNullOrEmpty(contentMd5Hash)) { // Optional. Provider returns HmacResult.ContentMd5NotMatching if there's no match. request.Headers.Add(HttpRequestHeader.ContentMd5, contentMd5Hash); } var messageRepresentation = CreateMessageRepresentation(context, contentMd5Hash, timestamp, true); //Debug.WriteLine(messageRepresentation); var signature = CreateSignature(context.SecretKey, messageRepresentation); request.Headers.Add(HttpRequestHeader.Authorization, CreateAuthorizationHeader(signature)); if (data != null) { using (var stream = request.GetRequestStream()) { stream.Write(data, 0, data.Length); } } requestContent.Insert(0, request.Headers.ToString()); return(request); }
public bool HasRoutes() { return(_routeData?.Any() ?? false); }