public void Run(BuildTarget target, NodeData node, ConnectionPointData inputPoint, ConnectionData connectionToOutput, Dictionary<string, List<Asset>> inputGroupAssets, List<string> alreadyCached, Action<ConnectionData, Dictionary<string, List<Asset>>, List<string>> Output) { var incomingAssets = inputGroupAssets.SelectMany(v => v.Value).ToList(); var modifier = ModifierUtility.CreateModifier(node, target); UnityEngine.Assertions.Assert.IsNotNull(modifier); bool isAnyAssetModified = false; foreach(var asset in incomingAssets) { var loadedAsset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(asset.importFrom); if(modifier.IsModified(loadedAsset)) { modifier.Modify(loadedAsset); isAnyAssetModified = true; } } if(isAnyAssetModified) { // apply asset setting changes to AssetDatabase. AssetDatabase.Refresh(); } // Modifier does not add, filter or change structure of group, so just pass given group of assets Output(connectionToOutput, inputGroupAssets, null); }
/// <summary> /// Detects which expressions in a <see cref="Grammar"/> are left-adjacent. /// </summary> /// <param name="grammar">The <see cref="Grammar"/> to inspect.</param> /// <returns>A <see cref="ILookup{Rule, Expression}"/> containing the left-adjacent rules.</returns> public static ILookup<Rule, Expression> Detect(Grammar grammar) { var leftAdjacent = new Dictionary<Rule, List<Expression>>(); var zeroWidth = ZeroWidthEvaluator.Evaluate(grammar); new LeftRecursionExpressionTreeWalker(zeroWidth, leftAdjacent).WalkGrammar(grammar); return leftAdjacent.SelectMany(i => i.Value, (i, v) => new { i.Key, Value = v }).ToLookup(i => i.Key, i => i.Value); }
public TagConverter(ISettingsProvider settingsProvider) { using (var reader = new StreamReader(settingsProvider.Get<string>(SettingsKeys.TagMappingFile))) { normalizedTags = reader .ReadAllLines() .Where(x => !string.IsNullOrWhiteSpace(x)) .Select(ParseTagDescription) .ToDictionary(x => x.Name, x => x.RawTags); rawTagsMapping = normalizedTags .SelectMany(normalizedTag => normalizedTag.Value.Select(rawTag => new { Normalized = normalizedTag.Key, Raw = rawTag })) .ToDictionary(x => x.Raw, x => x.Normalized); } using (var reader = new StreamReader(settingsProvider.Get<string>(SettingsKeys.CorrectionsFile))) { correctionsByProblemUrl = reader .ReadAllLines() .Where(x => !string.IsNullOrWhiteSpace(x)) .SelectMany(ParseCorrections) .GroupBy(x => x.ProblemUrl) .ToDictionary(x => x.Key, x => x.ToArray()); } }
public static IEnumerable <Type> FindTypes <T>() { Type targetType = typeof(T); return(assemblyAndTypes?.SelectMany(kvp => kvp.Value) .Where(type => targetType.IsAssignableFrom(type))); }
private static IEnumerable<dynamic> LetterValuePairs( Dictionary<int, IList<string>> old) { return old.SelectMany( kvp => kvp.Value.Select( letter => new {Letter = letter.ToLower(), Value = kvp.Key})); }
/// <summary> /// Initializes a new instance of the <see cref="FakeDataQueue"/> class to randomly emit data for each symbol /// </summary> public FakeDataQueue() { _ticks = new ConcurrentQueue<BaseData>(); _symbols = new Dictionary<SecurityType, List<string>>(); _timer = new Timer { AutoReset = true, Enabled = true }; _timer.Elapsed += (sender, args) => { _timer.Interval = _random.Next(15, 2500); // around each second foreach (var symbol in _symbols.SelectMany(x => x.Value)) { // 50/50 repeating chance of emitting each symbol while (_random.NextDouble() > 0.75) { _ticks.Enqueue(new Tick { Time = DateTime.Now, Symbol = symbol, Value = 10 + (decimal) Math.Abs(Math.Sin(DateTime.Now.TimeOfDay.TotalMinutes)), TickType = TickType.Trade, Quantity = _random.Next(10, (int) _timer.Interval) }); } } }; }
public void Given_30_New_Tweets_GetLatest_Returns_Tweets_In_Correct_Order() { var queryTweets = new Dictionary<string, IEnumerable<Item>> { { "#hashtag", BuildTweets(5) }, { "@user", BuildTweets(10) }, { "text", BuildTweets(15) } }; var minDate = queryTweets.SelectMany(kv => kv.Value).Select(f => f.Published).Min(); var maxDate = queryTweets.SelectMany(kv => kv.Value).Select(f => f.Published).Max(); var twitterAggregator = BuildTwitterAggregator(queryTweets); var tweets = twitterAggregator.GetLatest(DateTime.MinValue).ToList(); Assert.AreEqual(minDate, tweets.First().Published); Assert.AreEqual(maxDate, tweets.Last().Published); }
public void Given_30_New_Feeds_GetLatest_Returns_Feeds_In_Correct_Order() { var urlFeeds = new Dictionary<string, IEnumerable<Item>> { { "http://atom1", BuildFeeds(5) }, { "http://atom2", BuildFeeds(10) }, { "http://atom3", BuildFeeds(15) } }; var minDate = urlFeeds.SelectMany(kv => kv.Value).Select(f => f.Published).Min(); var maxDate = urlFeeds.SelectMany(kv => kv.Value).Select(f => f.Published).Max(); var rssAggregator = BuildRssAggregator(urlFeeds); var feeds = rssAggregator.GetLatest(DateTime.MinValue).ToList(); Assert.AreEqual(minDate, feeds.First().Published); Assert.AreEqual(maxDate, feeds.Last().Published); }
public IList GetAllErrors(string[] propertyNames = null) { if (propertyNames?.Any() == true) { return(_errors?.Where(error => propertyNames.Contains(error.Key)).SelectMany(error => error.Value).ToList()); } return(_errors?.SelectMany(error => error.Value).ToList()); }
private string[] GetDistinctFieldCodes(Dictionary<TemplateModel, List<FieldCodeSummaryModel>> analysisData) { var distinctFieldCodes = new List<string>(); foreach (var fieldCodeSummary in analysisData.SelectMany(i => i.Value.Where(fc => !distinctFieldCodes.Contains(fc.ColumnName)))) { distinctFieldCodes.Add(fieldCodeSummary.ColumnName); } return distinctFieldCodes.OrderBy(fc => fc).ToArray(); }
public Job(string name, string rowScope, Dictionary<string, List<Column>> capturePathToColumns, TextWriter textWriter) { _rowScope = rowScope; _capturePathToColumn = capturePathToColumns; Name = name; List<string> columnNames = capturePathToColumns.SelectMany(x => x.Value.Select(y => y.Name)).ToList(); Writer = new Writer(columnNames, textWriter); }
public List<Fork> Search(Dictionary<SportType, Dictionary<GameInfo, List<Game>>> games) { if (games == null) { throw new ArgumentNullException(nameof(games)); } return games.SelectMany(pair => this.GetForks(pair.Key, pair.Value)).ToList(); }
public IEnumerable<BlogPost> GetItems(int feedCount = 20, int pagenum = 0) { string json = File.ReadAllText("feeddata.json"); var metadataEntries = json.FromJson<MetaData[]>(); var syndicationFeeds = new Dictionary<string, SyndicationFeed>(); foreach (var metadata in metadataEntries) { var reader = XmlReader.Create(metadata.FeedUrl); var feed = SyndicationFeed.Load(reader); reader.Close(); if (feed != null) { syndicationFeeds.Add(metadata.Id, feed); } } var data = syndicationFeeds .SelectMany(pair => pair.Value.Items, (pair, item) => new { Id = pair.Key, Item = item }) .Where(x => x.Item.Categories.Any(y => y.Name.ToLower() == "nancy" || y.Name.ToLower() == "nancyfx")) .Select(x => { var rssauthor = x.Item.Authors.FirstOrDefault(); var metaauthor = metadataEntries.FirstOrDefault(y => y.Id == x.Id); var authorname = string.Empty; var authoremail = string.Empty; if (metaauthor != null) { authorname = rssauthor == null ? metaauthor.Author : rssauthor.Name; authoremail = rssauthor == null ? metaauthor.AuthorEmail : rssauthor.Email; } var link = x.Item.Links.FirstOrDefault(); var locallink = link == null ? string.Empty : link.Uri.PathAndQuery; var originallink = link == null ? string.Empty : link.Uri.AbsoluteUri; return new BlogPost { Title = x.Item.Title.Text, Summary = x.Item.Summary.Text, Author = authorname, AuthorEmail = authoremail, Localink = locallink, OriginalLink = originallink }; }) .Skip(feedCount * pagenum) .Take(feedCount) .OrderByDescending(x => x.PublishedDate) ; return data; }
public FakeNewsServer(Dictionary<int, int[]> channelsByAccount) { var endDate = DateTime.Now.AddHours(-1); var startDate = endDate.AddDays(-40); this.channelsByAccount = channelsByAccount; var channels = channelsByAccount.SelectMany(ca => ca.Value).Distinct(); newsByChannel = channels.ToDictionary(c => c, c => NewsMaker.MakeSomeNews(c, startDate, endDate, 1, random.Next(100) < 50 ? random.Next(1, 10) : random.Next(2, 1440))); }
public static byte[] GetPJL(Dictionary<string, string> jobattribs, Dictionary<string, string> pjlsettings, string language) { return Encoding.ASCII.GetBytes( "\x1B%-12345X".ToArray() .Concat("@PJL JOB MODE=PRINTER\r\n") .Concat(jobattribs == null ? new char[] { } : jobattribs.SelectMany(kvp => "@PJL SET JOBATTR=\"@".ToArray().Concat(kvp.Key).Concat("=").Concat(kvp.Value).Concat("\"\r\n"))) .Concat(pjlsettings == null ? new char[] { } : pjlsettings.SelectMany(kvp => "@PJL SET ".ToArray().Concat(kvp.Key).Concat("=").Concat(kvp.Value).Concat("\r\n"))) .Concat("@PJL ENTER LANGUAGE=") .Concat(language) .Concat("\r\n") .ToArray() ); }
public void TestDetectionEngine() { Dictionary<string, IList<ISoundSignalReader>> learningWordSignals = new Dictionary<string, IList<ISoundSignalReader>>(); Dictionary<string, IList<ISoundSignalReader>> testWordSignals = new Dictionary<string, IList<ISoundSignalReader>>(); var learningDirectories = Directory.GetDirectories("Sounds\\Learning"); var testDirectories = Directory.GetDirectories("Sounds\\test"); foreach (var directory in learningDirectories.Where(item => !item.Contains("catalog"))) { var word = new DirectoryInfo(directory).Name; learningWordSignals.Add(word, new List<ISoundSignalReader>()); var wavFiles = Directory.GetFiles(directory).Select(item => new FileInfo(item)).Where(fItem => fItem.Extension.Contains("wav")); foreach (var file in wavFiles) { learningWordSignals[word].Add(new WavSoundSignalReader(file.FullName)); } } foreach (var directory in testDirectories) { var word = new DirectoryInfo(directory).Name; testWordSignals.Add(word, new List<ISoundSignalReader>()); var wavFiles = Directory.GetFiles(directory).Select(item => new FileInfo(item)).Where(fItem => fItem.Extension.Contains("wav")); foreach (var file in wavFiles) { testWordSignals[word].Add(new WavSoundSignalReader(file.FullName)); } } var catalogSignals = new List<ISoundSignalReader>(); catalogSignals.AddRange(learningWordSignals.SelectMany(item => item.Value)); var codeBook = CodeBookFactory.FromWaves(catalogSignals, EngineParameters.Default); var recognitionEngine = new DetectionEngine(codeBook); var result = recognitionEngine.Train(learningWordSignals); foreach (var word in testWordSignals) { foreach (var signal in word.Value) { string name; var value = recognitionEngine.Recognize(signal, out name); Assert.AreEqual(word.Key, name); } } }
/// <summary> /// Process the content of Claim files and change to structure we want for Result file /// </summary> /// <param name="rows">content of claim file</param> /// <returns></returns> public ProcessClaimFileResult Process(Dictionary<string, Dictionary<int, List<BaseClaimRowMetaData>>> rows) { if (!rows.Any()) { //We can throw Exception here too, depend on our policies return new ProcessClaimFileResult{Exception = new ProcessFileRowNotFoundException() }; } var originYears = rows.SelectMany(r => r.Value.Select(v => v.Key)).Distinct().OrderBy(o => o).ToArray(); _earliestOriginYear = originYears.First(); _lastDevelopmentYear = originYears.Last(); _numberOfDevelopment = _lastDevelopmentYear - _earliestOriginYear + 1; var accumulatedTriangle = CalculateAccumulatedTriangle(rows); return new ProcessClaimFileResult { EarliestOriginYear = _earliestOriginYear, NumberOfDevelopment = _numberOfDevelopment, AccumulatedTriangle = accumulatedTriangle }; }
private GameResult GetResults(TagInfo tag, PlayersRepo playersRepo, Dictionary<string, PlayerAnswers> playerAnswers) { IDictionary<string, int> wordStats = playerAnswers.SelectMany(ans => ans.Value.Answers).CountStatistics(word => word); return new GameResult { Results = playerAnswers.Keys.Select( k => new PlayerResult { Player = playersRepo.Find(k), WordsScores = playerAnswers[k].Answers.Select(ans => Tuple.Create(ans, wordStats[ans])).ToArray(), Score = playerAnswers[k].Answers.Sum(ans => wordStats[ans]) } ).OrderByDescending(p => p.Score).ToArray(), Tag = tag, WordsScores = wordStats.OrderByDescending(kv => kv.Value).Select(kv => Tuple.Create(kv.Key, kv.Value)).ToArray() }; }
protected IEnumerable<BsaFolder> BuildBsaLayout(Dictionary<string, IList<FileRecord>> folderDict, IList<string> fileNames) { var pathedFiles = folderDict .SelectMany(kvp => kvp.Value.Select(record => new { path = kvp.Key, record })) .Zip(fileNames, (a, fn) => new { a.path, fn, a.record }); var fileLookup = pathedFiles.ToLookup(a => a.path, a => new { a.fn, a.record }); return from g in fileLookup let bsaFiles = g.Select(a => new BsaFile( g.Key, a.fn, Settings, a.record, (off, len) => _mmf.ToReader(a.record.offset + off, len))) select new BsaFolder(g.Key, bsaFiles); }
private static void Main() { var configsList = new List<string> { "Name: Link, Level: 1, Hp: 20", "Name: Zelda, Level: 1, Hp: 20 ", "Name: Zelda, Hp: 30", "Name: Mario, Hp: 30" }; var gamesDic = new Dictionary<string, Dictionary<string,string>>(); foreach (var configs in configsList) { UpdateDictionary(configs, gamesDic); } foreach (var kvp in gamesDic.SelectMany(games => games.Value)) { Console.WriteLine($"{kvp.Key}:{kvp.Value}"); } Console.ReadKey(); }
public void EntityDiff_GetByRelationships() { // Arrange var dbEntities = new HashSet <Dummy>(AllEntities.Select(e => new Dummy { Id = e.Id }).ToList()); DiffableEntityHashSet <Dummy> diffs = new DiffableEntityHashSet <Dummy>(AllEntities, dbEntities, Relationships, null); // Act Dictionary <RelationshipAttribute, HashSet <Dummy> > toOnes = diffs.GetByRelationship <ToOne>(); Dictionary <RelationshipAttribute, HashSet <Dummy> > toManies = diffs.GetByRelationship <ToMany>(); Dictionary <RelationshipAttribute, HashSet <Dummy> > notTargeted = diffs.GetByRelationship <NotTargeted>(); Dictionary <RelationshipAttribute, HashSet <Dummy> > allRelationships = diffs.AffectedRelationships; // Assert AssertRelationshipDictionaryGetters(allRelationships, toOnes, toManies, notTargeted); var allEntitiesWithAffectedRelationships = allRelationships.SelectMany(kvp => kvp.Value).ToList(); NoRelationshipsEntities.ToList().ForEach(e => { Assert.DoesNotContain(e, allEntitiesWithAffectedRelationships); }); var requestEntitiesFromDiff = diffs; requestEntitiesFromDiff.ToList().ForEach(e => { Assert.Contains(e, AllEntities); }); var databaseEntitiesFromDiff = diffs.GetDiffs().Select(d => d.DatabaseValue); databaseEntitiesFromDiff.ToList().ForEach(e => { Assert.Contains(e, dbEntities); }); }
/// <summary> /// Loads all the members from YAML metadata files, and group them by parent type. /// </summary> private static ILookup <string, Member> LoadMembersByType(string metadataDir) { var dictionary = new Dictionary <string, List <Member> >(); // Urgh - there must be a nicer way of doing this. foreach (var file in Directory.GetFiles(metadataDir, "Google*.yml")) { using (var input = File.OpenText(file)) { var model = new Deserializer(namingConvention: new CamelCaseNamingConvention(), ignoreUnmatched: true).Deserialize <CodeModel>(input); // Assume we only want classes and structs at the moment... var type = model.Items.FirstOrDefault(x => x.Type == "Class" || x.Type == "Struct"); if (type == null) { continue; } var members = model.Items.Where(x => x.Parent == type.Uid).ToList(); dictionary[type.Uid] = members; } } return(dictionary .SelectMany(pair => pair.Value.Select(m => new { pair.Key, Value = m })) .ToLookup(pair => pair.Key, pair => pair.Value)); }
public SaveResult SaveChanges(JObject saveBundle) { var jsonSerializer = CreateJsonSerializer(); var dynSaveBundle = (dynamic)saveBundle; var entitiesArray = (JArray)dynSaveBundle.entities; var dynSaveOptions = dynSaveBundle.saveOptions; SaveOptions = (SaveOptions)jsonSerializer.Deserialize(new JTokenReader(dynSaveOptions), typeof(SaveOptions)); // SaveOptions = ExtractSaveOptions(saveBundle); EntitiesWithAutoGeneratedKeys = new List <EntityInfo>(); var saveMap = new Dictionary <Type, List <EntityInfo> >(); var jObjects = entitiesArray.Select(jt => (dynamic)jt).ToList(); var groups = jObjects.GroupBy(jo => (String)jo.entityAspect.entityTypeName).ToList(); groups.ForEach(g => { var entityType = LookupEntityType(g.Key); var entityInfos = g.Select(jo => (EntityInfo)CreateEntityInfoFromJson(jo, entityType, jsonSerializer)) .Where(BeforeSaveEntity) .ToList(); EntitiesWithAutoGeneratedKeys.AddRange(entityInfos.Where(ei => ei.AutoGeneratedKey != null)); saveMap.Add(entityType, entityInfos); }); saveMap = BeforeSaveEntities(saveMap); var keyMappings = SaveChangesCore(saveMap); var entities = saveMap.SelectMany(kvp => kvp.Value.Select(entityInfo => entityInfo.Entity)).ToList(); return(new SaveResult() { Entities = entities, KeyMappings = keyMappings }); }
public static void CreatePermutations(int maxDim = 10) { AllPermutations.Clear(); maxDim = Math.Min(10, maxDim); // Maximum dimension is 10, and 10!=3,628,800 for complexity var permutations = new Dictionary <int, List <List <int> > >(); permutations[1] = new List <List <int> >() { new List <int>() { 0 } }; for (int k = 1; k < maxDim; ++k) { permutations[k + 1] = AddDimension(permutations[k]); } AllPermutations = permutations.SelectMany(e => e.Value) .Select(l => new Permutation(l)) .GroupBy(e => e.Dim) .ToDictionary(a => a.Key, b => b.ToList()); }
private void OnMonitorNotification(MonitoredItem monitoreditem, MonitoredItemNotificationEventArgs e) { VariableNode varNode = (VariableNode)monitoreditem.Subscription.Session.ReadNode(monitoreditem.StartNodeId); foreach (var value in monitoreditem.DequeueValues()) { Console.WriteLine("Got a value"); var typeManager = new DataTypeManager(monitoreditem.Subscription.Session); UaValue opcvalue = typeManager.GetUaValue(varNode, value, false); dynamic monitorInfoPair; lock (_monitorPublishInfo) { monitorInfoPair = _monitorPublishInfo .SelectMany(pair => pair.Value, (parent, child) => new { ServerUrl = parent.Key, Info = child }) .First(couple => couple.Info.Subscription == monitoreditem.Subscription); } var message = $"[TOPIC: /*{monitorInfoPair.Info.Topic}]*/ \t ({monitoreditem.DisplayName}):{opcvalue.Value}"; monitorInfoPair.Info.Forward(message); Console.WriteLine(message); } }
protected override void OnClosed(EventArgs e) { if (Trader != null) { if (_initialized) { Trader.MarketDepthsChanged -= TraderOnMarketDepthsChanged; } if (_scannerId != null) { Trader.UnSubscribeScanner(_scannerId.Value); _scannerId = null; } _reportSecurities.SelectMany(p => p.Value).ForEach(Trader.UnSubscribeFundamentalReport); _optionSecurities.ForEach(p => Trader.UnSubscribeOptionCalc(p.Value)); _reportSecurities.Clear(); _optionSecurities.Clear(); } base.OnClosed(e); }
private void Publish(Dictionary <Type, List <EntityInfo> > saveMap) { if (EventPublisher == null) { return; } foreach (var entity in saveMap.SelectMany(t => saveMap[t.Key])) { switch (entity.EntityState) { case EntityState.Added: EventPublisher?.Publish(new EntityAdded(entity)); break; case EntityState.Deleted: EventPublisher?.Publish(new EntityDeleted(entity)); break; case EntityState.Modified: EventPublisher?.Publish(new EntityUpdated(entity)); break; } } }
private MarginTradingAccount[] GetClientAccounts(string clientId) { _lockSlim.EnterReadLock(); try { if (clientId != null) { if (_accounts.ContainsKey(clientId)) { return(_accounts[clientId]); } return(Array.Empty <MarginTradingAccount>()); } else { return(_accounts.SelectMany(a => a.Value).ToArray()); } } finally { _lockSlim.ExitReadLock(); } }
public async Task <GroupAssignment> Assign(ClusterManager metadata, GroupSubscription groupSubscription) { Dictionary <string, Subscription> subscriptions = groupSubscription.groupSubscription(); var allSubscribedTopics = new HashSet <string>(); foreach (var topic in subscriptions.SelectMany(e => e.Value.Topics)) { allSubscribedTopics.Add(topic); } var partitionsPerTopic = new Dictionary <string, int>(); foreach (string topic in allSubscribedTopics) { int numPartitions = (await metadata.GetTopic(topic)).Partitions.Count; if (numPartitions > 0) { partitionsPerTopic.Add(topic, numPartitions); } else { log.debug("Skipping assignment for topic {} since no metadata is available", topic); } } Dictionary <string, List <TopicPartition> > rawAssignments = Assign(partitionsPerTopic, subscriptions); // this class maintains no user data, so just wrap the results var assignments = new Dictionary <string, Assignment>(); foreach (var assignmentEntry in rawAssignments) { assignments.Add(assignmentEntry.Key, new Assignment(0, assignmentEntry.Value, null)); } return(new GroupAssignment(assignments)); }
internal async static void ClearIdleConnections() { clearConenctions = true; while (clearConenctions) { await connectionAccessLock.WaitAsync(); try { var cutOff = DateTime.Now.AddMinutes(-1 * ProxyServer.ConnectionCacheTimeOutMinutes); connectionCache .SelectMany(x => x.Value) .Where(x => x.LastAccess < cutOff) .ToList() .ForEach(x => x.TcpClient.Close()); connectionCache.ToList().ForEach(x => x.Value.RemoveAll(y => y.LastAccess < cutOff)); } finally { connectionAccessLock.Release(); } await Task.Delay(1000 * 60 * 3).ConfigureAwait(false); } }
public override void Render() { if (!Settings.Enable || !GameController.InGame || !Settings.ShowInTown && GameController.Area.CurrentArea.IsTown) { return; } RectangleF windowRectangle = GameController.Window.GetWindowRectangle(); var windowSize = new Size2F(windowRectangle.Width / 2560, windowRectangle.Height / 1600); Camera camera = GameController.Game.IngameState.Camera; Func <HealthBar, bool> showHealthBar = x => x.IsShow(Settings.ShowEnemies); Parallel.ForEach(healthBars, x => x.Value.RemoveAll(hp => !(hp.Entity.IsValid && hp.Entity.IsAlive))); foreach (HealthBar healthBar in healthBars.SelectMany(x => x.Value).AsParallel().AsOrdered().Where(showHealthBar)) { Vector3 worldCoords = healthBar.Entity.Pos; Vector2 mobScreenCoords = camera.WorldToScreen(worldCoords.Translate(0, 0, -170), healthBar.Entity); if (mobScreenCoords != new Vector2()) { DrawHealthBar(healthBar, windowSize, mobScreenCoords); } } }
private static void AssertFieldsAreSupported( IEnumerable <string> aggregationFields, Dictionary <string, AggregateQuery> aggregateQueries) { // First, get a distinct list of all the requested columns. string[] requestedFields = aggregateQueries .SelectMany(x => x.Value.DataFilters) .Select(x => x.Field) .Distinct() .ToArray(); // Then, check if any columns been requested that are not // available. string[] unsupportedFields = requestedFields .Where(x => !aggregationFields.Any(y => y == x)) .ToArray(); if (unsupportedFields.Length > 0) { throw new UnsupportedAggregateColumnRequestException( unsupportedFields, aggregationFields); } }
public bool IsGraphBipartite() { BFS(1); if (Nums.Count(element => element == 0) != 0) { return(false); } var even = new Dictionary <int, List <int> >(); var odd = new Dictionary <int, List <int> >(); for (var i = 1; i < Nums.Length; i++) { TryAddValue(Nums[i] % 2 == 0 ? even : odd, Nums[i], i); } if (HasAdjacentNodesOfSameLevel(even) || HasAdjacentNodesOfSameLevel(odd)) { return(false); } PartEven = even.SelectMany(x => x.Value).ToList(); PartOdd = odd.SelectMany(x => x.Value).ToList(); return(true); }
private async Task <List <ModDependencyInfo> > GetDependencies(CancellationToken cancellationToken) { ICollection <Mod> selectedMods = new List <Mod>(Mods.Where(mod => mod.IsSelected)); if (selectedMods.Count == 0) { selectedMods = Mods; } var dict = new Dictionary <string, Dictionary <Version, ModDependencyInfo> >(); var infos = new Dictionary <string, ExtendedModInfo>(); foreach (var mod in selectedMods) { if (cancellationToken.IsCancellationRequested) { break; } await AddDependencies(dict, infos, mod, cancellationToken); } return(new List <ModDependencyInfo>(dict.SelectMany(kvp => kvp.Value.Values))); }
private static Solution AddProjectReferences( Solution solution, string projectName, IEnumerable <string> projectReferences ) { var referencesByTargetProject = new Dictionary <string, List <ProjectReference> >(); foreach (var targetProject in projectReferences) { var references = referencesByTargetProject.GetOrAdd( targetProject, _ => new List <ProjectReference>() ); if (references.Count == 0) { references.Add( new ProjectReference(solution.GetProjectsByName(targetProject).Single().Id) ); } else { references.Add( new ProjectReference( solution.GetProjectsByName(targetProject).Single().Id, ImmutableArray.Create($"alias{references.Count}") ) ); } } return(solution.AddProjectReferences( solution.GetProjectsByName(projectName).Single().Id, referencesByTargetProject.SelectMany(pair => pair.Value) )); }
private async Task GenerateSelectionAsync() { ToggleUI(false); using (new Wait()) { Dictionary <Template, List <TemplateOutputDefinitionFilenameResult> > templateOutputs = (from li in outputsListView.CheckedItems.Cast <ListViewItem>() group(TemplateOutputDefinitionFilenameResult) li.Tag by(Template) li.Group.Tag into g select new { Template = g.Key, Outputs = g.ToList() }).ToDictionary(o => o.Template, o => o.Outputs); if (templateOutputs.IsNullOrEmpty()) { MessageBox.Show("You must select one or more template you wish to generate.", "Generate", MessageBoxButtons.OK, MessageBoxIcon.Information); ToggleUI(true); return; } outputsListView.CheckedItems.Cast <ListViewItem>().ForEach(o => { o.SubItems[statusColumn.Index].Text = null; o.SubItems[messageColumn.Index].Text = null; }); progressBar.Value = 0; progressBar.Maximum = templateOutputs.SelectMany(o => o.Value).Count(); progressBar.Visible = true; this.Generator = new Generator(ProjectContext.Project, templateOutputs); this.Generator.GenerationStatus += new Generator.GenerationStatusEventHandler(Generator_GenerationStatus); this.Generator.TemplateGenerationStatus += new Generator.TemplateGenerationStatusEventHandler(Generator_TemplateGenerationStatus); this.Generator.ItemGenerationStatus += new Generator.ItemGenerationStatusEventHandler(Generator_ItemGenerationStatus); await this.Generator.GenerateAsync(); } }
private void SelectAddinForm_Load(object sender, EventArgs e) { this.Translate(); lvAddins.Clear(); lvAddins.Groups.Clear(); ilLarge.Images.Clear(); ilSmall.Images.Clear(); var addins = new Dictionary <string, IAddin>[] { Host.Actions, Host.Effects }; var addinList = addins.SelectMany(dict => dict) .ToDictionary(pair => pair.Key, pair => pair.Value); AddinItems.Clear(); foreach (var addin in addinList) { if (Host.CurrentFilter is IAddin && string.Equals(Host.CurrentFilter.Name, addin.Value.Name, StringComparison.CurrentCultureIgnoreCase)) { continue; } ilLarge.Images.Add(addin.Value.LargeIcon); ilSmall.Images.Add(addin.Value.SmallIcon); var lvi = new ListViewItem(); lvi.Text = addin.Value.DisplayName; lvi.Tag = addin.Value; lvi.ImageIndex = ilLarge.Images.Count - 1; AddinItems.Add(lvi); } lvAddins.VirtualListSize = AddinItems.Count; btnGroupType.PerformClick(); }
/// <summary> /// Add new record to database /// </summary> /// <param name="backtraceData">Diagnostic data that should be stored in database</param> /// <returns>New instance of DatabaseRecordy</returns> public BacktraceDatabaseRecord Add(BacktraceData backtraceData) { if (backtraceData == null) { throw new NullReferenceException("backtraceData"); } string hash = GetHash(backtraceData); if (!string.IsNullOrEmpty(hash)) { var existRecord = BatchRetry.SelectMany(n => n.Value) .FirstOrDefault(n => n.Hash == hash); if (existRecord != null) { existRecord.Locked = true; existRecord.Increment(); TotalRecords++; return(existRecord); } } //add built-in attachments var attachments = _attachmentManager.GetReportAttachments(backtraceData); foreach (var attachment in attachments) { if (!string.IsNullOrEmpty(attachment)) { backtraceData.Report.AttachmentPaths.Add(attachment); backtraceData.Attachments.Add(attachment); } } var record = ConvertToRecord(backtraceData, hash); //add record to database context return(Add(record)); }
/// <summary> /// Add new record to database /// </summary> /// <param name="backtraceData">Diagnostic data that should be stored in database</param> /// <returns>New instance of DatabaseRecordy</returns> public virtual BacktraceDatabaseRecord Add(BacktraceData backtraceData, MiniDumpType miniDumpType = MiniDumpType.None) { if (backtraceData == null) { throw new NullReferenceException(nameof(backtraceData)); } string hash = GetHash(backtraceData); if (!string.IsNullOrEmpty(hash)) { var existRecord = BatchRetry.SelectMany(n => n.Value) .FirstOrDefault(n => n.Hash == hash); if (existRecord != null) { existRecord.Locked = true; existRecord.Increment(); TotalRecords++; return(existRecord); } } string minidumpPath = GenerateMiniDump(backtraceData.Report, miniDumpType); backtraceData.Report.SetMinidumpPath(minidumpPath); backtraceData.Attachments.Add(minidumpPath); //create new record and save it on hard drive var record = new BacktraceDatabaseRecord(backtraceData, _path) { Hash = hash }; record.Save(); //add record to database context return(Add(record)); }
/// <summary> /// Add new record to database /// </summary> /// <param name="backtraceData">Diagnostic data that should be stored in database</param> /// <returns>New instance of DatabaseRecordy</returns> public BacktraceDatabaseRecord Add(BacktraceData backtraceData, MiniDumpType miniDumpType = MiniDumpType.None) { if (backtraceData == null) { throw new NullReferenceException("backtraceData"); } string hash = GetHash(backtraceData); if (!string.IsNullOrEmpty(hash)) { var existRecord = BatchRetry.SelectMany(n => n.Value) .FirstOrDefault(n => n.Hash == hash); if (existRecord != null) { existRecord.Locked = true; existRecord.Increment(); TotalRecords++; return(existRecord); } } string minidumpPath = GenerateMiniDump(backtraceData.Report, miniDumpType); backtraceData.Report.SetMinidumpPath(minidumpPath); if (!string.IsNullOrEmpty(minidumpPath)) { backtraceData.Attachments.Add(minidumpPath); } var record = ConvertToRecord(backtraceData, hash); //add record to database context return(Add(record)); }
private void Train() { Dictionary<string, IList<ISoundSignalReader>> learningWordSignals = new Dictionary<string, IList<ISoundSignalReader>>(); List<string> learningDirectories = new List<string>(); foreach (var folder in ConfigurationSettings.LearningsFolders) { learningDirectories.AddRange(Directory.GetDirectories(folder)); } foreach (var directory in learningDirectories.Where(item => !item.Contains("catalog"))) { var word = new DirectoryInfo(directory).Name; learningWordSignals.Add(word, new List<ISoundSignalReader>()); var wavFiles = Directory.GetFiles(directory).Select(item => new FileInfo(item)).Where(fItem => fItem.Extension.Contains("wav")); foreach (var file in wavFiles) { learningWordSignals[word].Add(new WavSoundSignalReader(file.FullName)); } } var catalogSignals = new List<ISoundSignalReader>(); catalogSignals.AddRange(learningWordSignals.SelectMany(item => item.Value)); var codeBook = CodeBookFactory.FromWaves(catalogSignals, EngineParameters.Default); var recognitionEngine = new DetectionEngine(codeBook); var result = recognitionEngine.Train(learningWordSignals); //result.Hmm.Save("HMModels.dat"); _models = result.Models; _codebook = result.Catalog; result.Save("SavedData", "model"); }
public static Dictionary <string, int> Transform(Dictionary <int, string[]> old) => old.SelectMany(kvp => kvp.Value, (kvp, c) => (c.ToLower(), kvp.Key)).ToDictionary(p => p.Item1, p => p.Item2);
public void PostTraceReconciliation(Dictionary<Guid, List<ISerializable>> orphanedSerializables) { Assert.AreEqual(orphanedSerializables.SelectMany(kvp=>kvp.Value).Count(), ExpectedOrphanCount); }
private static async Task<HashSet<SourceDependencyInfo>> GatherPackageDependencyInfo(ResolutionContext context, IEnumerable<string> primaryTargetIds, IEnumerable<string> allTargetIds, IEnumerable<PackageIdentity> primaryTargets, IEnumerable<PackageIdentity> allTargets, NuGetFramework targetFramework, IEnumerable<SourceRepository> primarySources, IEnumerable<SourceRepository> allSources, CancellationToken token) { // get a distinct set of packages from all repos var combinedResults = new HashSet<SourceDependencyInfo>(PackageIdentity.Comparer); // get the dependency info resources for each repo // primary and all may share the same resources var depResources = new Dictionary<SourceRepository, Task<DepedencyInfoResource>>(); foreach (var source in allSources.Concat(primarySources)) { if (!depResources.ContainsKey(source)) { depResources.Add(source, source.GetResourceAsync<DepedencyInfoResource>(token)); } } // a resource may be null, if it is exclude this source from the gather var primaryDependencyResources = new List<Tuple<SourceRepository, DepedencyInfoResource>>(); foreach (var source in primarySources) { var resource = await depResources[source]; if (source != null) { primaryDependencyResources.Add(new Tuple<SourceRepository, DepedencyInfoResource>(source, resource)); } } var allDependencyResources = new List<Tuple<SourceRepository, DepedencyInfoResource>>(); foreach (var source in allSources) { var resource = await depResources[source]; if (source != null) { allDependencyResources.Add(new Tuple<SourceRepository, DepedencyInfoResource>(source, resource)); } } // track which sources have been searched for each package id Dictionary<SourceRepository, HashSet<string>> sourceToPackageIdsChecked = new Dictionary<SourceRepository, HashSet<string>>(); UpdateSourceToPackageIdsChecked(sourceToPackageIdsChecked, primaryDependencyResources); UpdateSourceToPackageIdsChecked(sourceToPackageIdsChecked, allDependencyResources); if (primaryTargetIds != null && allTargetIds != null) { // First, check for primary targets alone against primary source repositories alone var primaryIdsAsAllDiscoveredIds = new HashSet<string>(primaryTargetIds); await ProcessMissingPackageIds(combinedResults, primaryIdsAsAllDiscoveredIds, sourceToPackageIdsChecked, primaryDependencyResources, targetFramework, context, false, token); string missingPrimaryPackageId = primaryTargetIds.Where(p => !combinedResults.Any(c => c.Id.Equals(p, StringComparison.OrdinalIgnoreCase))).FirstOrDefault(); if (!String.IsNullOrEmpty(missingPrimaryPackageId)) { throw new InvalidOperationException(String.Format(Strings.PackageNotFound, missingPrimaryPackageId)); } var allIdsAsAllDiscoveredIds = new HashSet<string>(allTargetIds); await ProcessMissingPackageIds(combinedResults, allIdsAsAllDiscoveredIds, sourceToPackageIdsChecked, primaryDependencyResources, targetFramework, context, false, token); } else { Debug.Assert(primaryTargets != null && allTargets != null); // First, check for primary targets alone against primary source repositories alone await ProcessMissingPackageIdentities(combinedResults, primaryTargets, sourceToPackageIdsChecked, primaryDependencyResources, targetFramework, context, false, token); PackageIdentity missingPrimaryPackageIdentity = primaryTargets.Where(p => !combinedResults.Any(c => c.Equals(p))).FirstOrDefault(); if (missingPrimaryPackageIdentity != null) { throw new InvalidOperationException(String.Format(Strings.PackageNotFound, missingPrimaryPackageIdentity)); } await ProcessMissingPackageIdentities(combinedResults, allTargets, sourceToPackageIdsChecked, allDependencyResources, targetFramework, context, true, token); } // loop until we finish a full iteration with no new ids discovered bool complete = false; while (!complete) { HashSet<string> allDiscoveredIds = new HashSet<string>(sourceToPackageIdsChecked.SelectMany(e => e.Value), StringComparer.OrdinalIgnoreCase); complete = await ProcessMissingPackageIds(combinedResults, allDiscoveredIds, sourceToPackageIdsChecked, allDependencyResources, targetFramework, context, true, token); } return combinedResults; }
public bool IsPlanar(Graph graphArgument) { var enableCudafy = Settings.EnableCudafy; Settings.EnableCudafy = true; if (WorkerLog != null) { WorkerLog("Начало гамма-алгоритма"); } var graph = new Graph(graphArgument); Debug.Assert( graph.Children.All(pair => pair.Value .All(value => graph.Children.ContainsKey(value) && graph.Children[value].Contains(pair.Key))) ); if (WorkerBegin != null) { WorkerBegin(); } // Шаг первый - удаляем все листья и узлы степени 2 if (WorkerLog != null) { WorkerLog("Удаляем все листья и узлы степени 2"); } // листья представляют собой дерево и нарисовать его плоскую укладку тривиально. graph.RemoveAllTrees(); // Замечание. Если на ребра планарного графа нанести произвольное число вершин степени 2, // то он останется планарным; равным образом, если на ребра непланарного графа // нанести вершины степени 2, то он планарным не станет. graph.RemoveIntermedians(); // Шаг второй - граф нужно укладывать отдельно по компонентам связности. if (WorkerLog != null) { WorkerLog("Находим ВСЕ пути в графе длины не более размера графа + 1"); } Dictionary <int, PathDictionary> cachedAllGraphPaths = graph.GetAllGraphPaths(); var queue = new StackListQueue <Context> { graph.GetAllSubGraphs().Select(subgraph => new Context { SubGraphQueue = new StackListQueue <Graph> { subgraph }, CachedSubGraphPathsQueue = new StackListQueue <Dictionary <int, PathDictionary> > { Graph.GetSubgraphPaths(subgraph.Vertices, cachedAllGraphPaths) }, }) }; Debug.WriteLine("start "); foreach (Context context in queue) { while (context.SubGraphQueue.Any()) { Graph subGraph = context.SubGraphQueue.Dequeue(); if (WorkerLog != null) { WorkerLog("Проверка связанной компоненты " + subGraph); } Dictionary <int, PathDictionary> cachedSubGraphPaths = context.CachedSubGraphPathsQueue.Dequeue(); // На вход подаются графы, обладающие следующими свойствами: // граф связный; // граф имеет хотя бы один цикл; // граф не имеет мостиков, т. е. ребер, после удаления которых // граф распадается на две компонеты связности. if (WorkerLog != null) { WorkerLog( "Находим мосты после удаления которых граф распадается на несколько компонет связности"); } var vertices = new StackListQueue <Vertex>(subGraph.Vertices); var bridges = new StackListQueue <Vertex>(); for (int i = 0; i < vertices.Count; i++) { Vertex dequeue = vertices.Dequeue(); IEnumerable <Graph> subsubgraphs = subGraph.GetSubgraph(vertices).GetAllSubGraphs(); if (subsubgraphs.Count() > 1) { bridges.Add(dequeue); } vertices.Enqueue(dequeue); } Debug.Assert(bridges.Count != vertices.Count); if (bridges.Any()) { // Если в графе есть мосты, то их нужно разрезать, провести отдельно плоскую укладку // каждой компоненты связности, а затем соединить их мостами. // Здесь может возникнуть трудность: в процессе укладки концевые вершины моста могут // оказаться внутри плоского графа. Нарисуем одну компоненту связности, // и будем присоединять к ней другие последовательно. // Каждую новую компоненту связности будем рисовать в той грани, в которой лежит // концевая вершина соответствующего моста. Так как граф связности мостами компонент // связности является деревом, мы сумеем получить плоскую укладку. if (WorkerLog != null) { WorkerLog( "В графе есть мосты, их нужно разрезать, провести отдельно плоскую укладку, а затем соединить их мостами."); } if (WorkerLog != null) { WorkerLog("Мосты: " + string.Join(",", bridges)); } IEnumerable <Vertex> exceptBridges = vertices.Except(bridges); IEnumerable <Graph> subsubgraphs = subGraph.GetSubgraph(exceptBridges).GetAllSubGraphs(); Debug.WriteLine("subsubgraphs = " + subsubgraphs.Count()); context.SubGraphQueue.Enqueue( subsubgraphs.Select(subgraph => subGraph.GetSubgraph(subgraph.Vertices.Union(bridges)))); context.CachedSubGraphPathsQueue.Enqueue( subsubgraphs.Select( subgraph => Graph.GetSubgraphPaths(subgraph.Vertices.Union(bridges), cachedSubGraphPaths))); continue; } if (WorkerLog != null) { WorkerLog("Находим ЛЮБОЙ МАКСИМАЛЬНОЙ ДЛИНЫ простой цикл в графе"); } Circle circle = null; for (int i = cachedSubGraphPaths.Keys.Max(); i > 3; i--) { foreach (var pair in cachedSubGraphPaths.Where(pair => pair.Key == i)) { foreach ( var key in subGraph.Vertices.Select(vertex => new KeyValuePair <Vertex, Vertex>(vertex, vertex)) ) { if (pair.Value.ContainsKey(key) && pair.Value[key].Any()) { foreach (Path path in pair.Value[key]) { circle = new Circle(path.GetRange(0, path.Count - 1)); if (Circle.IsSimple(circle)) { break; } circle = null; } if (circle != null) { break; } } if (circle != null) { break; } } if (circle != null) { break; } } if (circle != null) { break; } } if (circle == null && !context.Edges.Any()) { // граф — дерево и нарисовать его плоскую укладку тривиально. // Поскольку мы ещё не начинали рисовать, то значит всё проверено continue; } // Инициализация алгоритма производится так: выбираем любой простой цикл; // и получаем две грани: Γ1 — внешнюю и Γ2 — внутреннюю if (circle != null && !context.Edges.Any()) { context.Edges.Add(new Edge(circle)); } if (circle != null) { context.Edges.Add(new Edge(circle)); context.Builded.Add(context.Edges.Last()); } // Если циклов нет, то надо проверить, что данное дерево // можно вписать в уже построенный граф Debug.WriteLine("SubGraph " + subGraph); Debug.WriteLine("builded " + context.Builded); Debug.WriteLine("edges:" + string.Join(Environment.NewLine, context.Edges.Select(e => e.ToString()))); //// Каждый сегмент S относительно уже построенного графа G′ представляет собой одно из двух: //// ребро, оба конца которого принадлежат G′, но само оно не принадлежит G′; //// связную компоненту графа G – G′, дополненную всеми ребрами графа G, //// один из концов которых принадлежит связной компоненте, //// а второй из графа G′. VertexSortedCollection buildedVertices = context.Builded.Vertices; Dictionary <int, PathDictionary> fromTo = Graph.GetFromToPaths(buildedVertices, buildedVertices, cachedSubGraphPaths); var paths = new PathCollection(fromTo .SelectMany(pair => pair.Value) .SelectMany(pair => pair.Value) .Where(Path.IsNoVertix) .Where(Path.IsNoCircle) ); Debug.WriteLine("paths " + paths); //var secondGraph = new Graph(subGraph.Except(context.Builded)); //if (secondGraph.Any()) //{ // IEnumerable<Graph> collection = secondGraph.GetAllSubGraphs(); // context.SubGraphQueue.Enqueue(collection); // context.CachedSubGraphPathsQueue.Enqueue( // collection.Select(subgraph => Graph.GetSubgraphPaths(subgraph.Vertices, cachedSubGraphPaths))); //} paths.ReplaceAll(paths.Distinct()); Debug.WriteLine("paths " + paths); paths.RemoveAll(context.Builded.Contains); Debug.WriteLine("paths " + paths); Debug.WriteLine("builded " + context.Builded); Debug.WriteLine("edges:" + string.Join(Environment.NewLine, context.Edges.Select(e => e.ToString()))); while (paths.Any()) { paths.RemoveAll(context.Builded.Contains); Debug.WriteLine("paths " + paths); if (!paths.Any()) { continue; } if (Settings.EnableCudafy) { try { while (paths.Any(Path.IsLong)) { // Находим для всех путей их перечечения с уже построенным графом // Разбиваем пути в найденных точках пересечения с уже построенным графом // Если точек пересечения не найдено, то выходим из цикла int[,] matrix; int[] indexes; lock (CudafySequencies.Semaphore) { CudafySequencies.SetSequencies( paths.Select( path => path.GetRange(1, path.Count - 2) .Select(vertex => vertex.Id) .ToArray()) .ToArray(), context.Builded.Vertices.Select( vertex => new StackListQueue <int>(vertex.Id).ToArray()) .ToArray() ); CudafySequencies.Execute("CountIntersections"); // подсчитываем число пересечений matrix = CudafySequencies.GetMatrix(); } lock (CudafyMatrix.Semaphore) { CudafyMatrix.SetMatrix(matrix); CudafyMatrix.ExecuteRepeatZeroIndexOfNonZero(); // находим индексы ненулевых элементов в строках indexes = CudafyMatrix.GetIndexes(); } Dictionary <int, int> dictionary = indexes.Select( (value, index) => new KeyValuePair <int, int>(index, value)) .Where(pair => pair.Value >= 0) .ToDictionary(pair => pair.Key, pair => pair.Value); if (!dictionary.Any()) { break; } Debug.Assert(dictionary.All(pair => pair.Key >= 0)); Debug.Assert(dictionary.All(pair => pair.Value >= 0)); Debug.Assert(dictionary.All(pair => pair.Key < paths.Count)); Debug.Assert(dictionary.All(pair => pair.Value < context.Builded.Vertices.Count)); var dictionary2 = new StackListQueue <KeyValuePair <Path, Vertex> >( dictionary.Select( pair => new KeyValuePair <Path, Vertex>(new Path(paths[pair.Key]), new Vertex(context.Builded.Vertices[pair.Value]))) ); var list = new StackListQueue <int>(dictionary.Select(pair => pair.Key).Distinct()); list.Sort(); Debug.Assert(dictionary2.All(pair => pair.Key.Count > 1)); for (int i = list.Count; i-- > 0;) { paths.RemoveAt(list[i]); } paths.AddRangeExcept( new PathCollection( dictionary2.SelectMany(pair => pair.Key.SplitBy(pair.Value) .Where(Path.IsNoVertix) .Where(Path.IsNoCircle)) .Distinct())); paths.ReplaceAll(paths.Distinct()); paths.RemoveAll(context.Builded.Contains); } } catch (Exception ex) { if (WorkerLog != null) { WorkerLog(ex.ToString()); } paths.ReplaceAll( paths.SelectMany(context.Builded.Split) .Where(Path.IsNoVertix) .Where(Path.IsNoCircle) ); paths.ReplaceAll(paths.Distinct()); paths.RemoveAll(context.Builded.Contains); } }
static SampleSpecsTestCaseData() { string specAssemblyPath = TestConstants.SampleSpecsDllPath; string sourceCodeFilePath = TestUtils.FirstCharToLower(TestConstants.SampleSpecsSourcePath); ByClassMethodExampleName = new Dictionary <string, Dictionary <string, Dictionary <string, TestCase> > >() { { "SampleSpecs.ParentSpec", new Dictionary <string, Dictionary <string, TestCase> >() { { "method_context_1", new Dictionary <string, TestCase>() { { "parent example 1A", new TestCase( "nspec. ParentSpec. method context 1. parent example 1A.", Constants.ExecutorUri, specAssemblyPath) { DisplayName = "ParentSpec › method context 1 › parent example 1A.", CodeFilePath = sourceCodeFilePath, LineNumber = 19, } }, { "parent example 1B", new TestCase( "nspec. ParentSpec. method context 1. parent example 1B.", Constants.ExecutorUri, specAssemblyPath) { DisplayName = "ParentSpec › method context 1 › parent example 1B.", CodeFilePath = sourceCodeFilePath, LineNumber = 21, } }, } }, { "method_context_2", new Dictionary <string, TestCase>() { { "parent example 2A", new TestCase( "nspec. ParentSpec. method context 2. parent example 2A.", Constants.ExecutorUri, specAssemblyPath) { DisplayName = "ParentSpec › method context 2 › parent example 2A.", CodeFilePath = sourceCodeFilePath, LineNumber = 26, } }, } }, } }, { "SampleSpecs.ChildSpec", new Dictionary <string, Dictionary <string, TestCase> >() { { "method_context_3", new Dictionary <string, TestCase>() { { "child example 3A skipped", new TestCase( "nspec. ParentSpec. ChildSpec. method context 3. child example 3A skipped.", Constants.ExecutorUri, specAssemblyPath) { DisplayName = "ParentSpec › ChildSpec › method context 3 › child example 3A skipped.", // no source code info available for pending tests CodeFilePath = String.Empty, LineNumber = 0, } }, } }, { "method_context_4", new Dictionary <string, TestCase>() { { "child example 4A", new TestCase( "nspec. ParentSpec. ChildSpec. method context 4. child example 4A.", Constants.ExecutorUri, specAssemblyPath) { DisplayName = "ParentSpec › ChildSpec › method context 4 › child example 4A.", CodeFilePath = sourceCodeFilePath, LineNumber = 42, } }, } }, { "method_context_5. sub context 5-1", new Dictionary <string, TestCase>() { { "child example 5-1A failing", new TestCase( "nspec. ParentSpec. ChildSpec. method context 5. sub context 5-1. child example 5-1A failing.", Constants.ExecutorUri, specAssemblyPath) { DisplayName = "ParentSpec › ChildSpec › method context 5 › sub context 5-1 › child example 5-1A failing.", CodeFilePath = sourceCodeFilePath, LineNumber = 49, } }, { "child example 5-1B", new TestCase( "nspec. ParentSpec. ChildSpec. method context 5. sub context 5-1. child example 5-1B.", Constants.ExecutorUri, specAssemblyPath) { DisplayName = "ParentSpec › ChildSpec › method context 5 › sub context 5-1 › child example 5-1B.", CodeFilePath = sourceCodeFilePath, LineNumber = 51, } }, } }, } }, }; All = ByClassMethodExampleName .SelectMany(byClassName => byClassName.Value) .SelectMany(byMethodName => byMethodName.Value) .Select(byExampleName => byExampleName.Value); ByTestCaseFullName = All.ToDictionary(tc => tc.FullyQualifiedName, tc => tc); // add implicit traits corresponding to class names // add explicit traits corresponding to tags All.Where(tc => tc.FullyQualifiedName.Contains("ParentSpec")) .Do(tc => tc.Traits.Add("ParentSpec", null)); All.Where(tc => tc.FullyQualifiedName.Contains("method context 1")) .Do(tc => { tc.Traits.Add("Tag-1A", null); tc.Traits.Add("Tag-1B", null); }); All.Where(tc => tc.FullyQualifiedName.Contains("ChildSpec")) .Do(tc => { tc.Traits.Add("ChildSpec", null); tc.Traits.Add("Tag-Child", null); }); All.Where(tc => tc.FullyQualifiedName.Contains("method context 3")) .Do(tc => tc.Traits.Add("Tag-Child-example-skipped", null)); All.Where(tc => tc.FullyQualifiedName.Contains("method context 4")) .Do(tc => tc.Traits.Add("Tag with underscores", null)); }
public void ToDot(string filename, Func <string, int, string> pathProcessor, List <HashSet <AbstractNode> > grouping) { using (var f = new StreamWriter(filename)) { f.WriteLine("digraph \"extractedGraph\"{");; // Write all nodes var allNodes = new HashSet <AbstractNode>(AllRelationships.Select(n => n.Key).Concat(AllRelationships.SelectMany(n => n.Value))); var nodeIds = new Dictionary <AbstractNode, int>(); int nextId = 0; int groupI = 0; foreach (var group in grouping) { groupI++; f.WriteLine("subgraph cluster_" + groupI.ToString() + " {" + "style=filled; color = lightgrey; node[style = filled, shape=box; color = white]; "); foreach (var node in group) { var removed = allNodes.Remove(node); Debug.Assert(removed); string path = "Unk/External"; if (node.Location != null && node.Location.SourceTree != null) { path = pathProcessor(node.Location.SourceTree.FilePath, node.Location.GetLineSpan().StartLinePosition.Line); } //f.WriteLine("n{0} [label=\"{1}\"]; //{2}", nextId, DotEscape(node.ToString()), path); f.WriteLine("n{0} [label=\"{1}\"]; ", nextId, /*DotEscape(node.ToDotString())*/ node.ToDotString()); nodeIds[node] = nextId; nextId++; } f.WriteLine("} //subgraph cluster_" + groupI.ToString()); } foreach (var parentChildrenPair in AllRelationships) { var parent = parentChildrenPair.Key; foreach (var child in parentChildrenPair.Value) { if (nodeIds.ContainsKey(parent) && nodeIds.ContainsKey(child)) { f.WriteLine("n{0}->n{1};", nodeIds[parent], nodeIds[child]); } } } f.WriteLine("}"); } }
public override void Weave( TypeDefinition typeDef, AssemblyDefinition assemblyDefinition, MapDefinition mapDefinition, Dictionary<string, List<MapDefinition>> assemblyMapDefinitions, Dictionary<string, AssemblyDefinition> assemblyDefinitions) { var boolTypeDef = typeDef.Module.Import(typeof(bool)); foreach (var columnDef in mapDefinition.ColumnDefinitions.Where( c => c.Relationship == RelationshipType.ManyToOne || c.Relationship == RelationshipType.OneToOne)) { // remember the property may be defined on a parent class var propDef = this.GetProperty(typeDef, columnDef.Name); // add a field with DbType and DbName TypeReference fkTypeReference; var fkPkType = columnDef.DbType.GetCLRType(); if (fkPkType.IsValueType) { fkTypeReference = typeDef.Module.Import(typeof(Nullable<>).MakeGenericType(fkPkType)); } else { fkTypeReference = typeDef.Module.Import(fkPkType); } var fkField = new FieldDefinition(columnDef.DbName, FieldAttributes.Public, fkTypeReference); if (propDef.DeclaringType.Fields.Any(f => f.Name == columnDef.DbName)) { continue; // already done something here! } this.MakeNotDebuggerBrowsable(typeDef.Module, fkField); propDef.DeclaringType.Fields.Add(fkField); // override the set method to set to null propDef.SetMethod.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Initobj, fkTypeReference)); propDef.SetMethod.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Ldflda, fkField)); propDef.SetMethod.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Ldarg_0)); // override the get method to access this field if null and create a new instance // TODO solve for non auto properties if (!propDef.GetMethod.Body.Variables.Any()) { // Release code is different to debug code! propDef.GetMethod.Body.Variables.Add(new VariableDefinition(propDef.PropertyType)); } propDef.GetMethod.Body.Variables.Add(new VariableDefinition(propDef.PropertyType)); propDef.GetMethod.Body.Variables.Add(new VariableDefinition(boolTypeDef)); propDef.GetMethod.Body.InitLocals = true; //propDef.GetMethod.Body.Instructions.Clear(); var backingField = this.GetBackingField(propDef); var il = propDef.GetMethod.Body.Instructions; var lastInstr = il[0]; var index = 0; // first bit does the null/hasValue checks on the backing fields il.Insert(index++, Instruction.Create(OpCodes.Ldarg_0)); il.Insert(index++, Instruction.Create(OpCodes.Ldfld, backingField)); il.Insert(index++, Instruction.Create(OpCodes.Brtrue, lastInstr)); if (fkPkType.IsValueType) { il.Insert(index++, Instruction.Create(OpCodes.Ldarg_0)); il.Insert(index++, Instruction.Create(OpCodes.Ldflda, fkField)); il.Insert( index++, Instruction.Create( OpCodes.Call, MakeGeneric( typeDef.Module.Import(fkTypeReference.Resolve().GetMethods().Single(m => m.Name == "get_HasValue")), typeDef.Module.Import(fkPkType)))); } else { il.Insert(index++, Instruction.Create(OpCodes.Ldarg_0)); il.Insert(index++, Instruction.Create(OpCodes.Ldfld, fkField)); } il.Insert(index++, Instruction.Create(OpCodes.Brfalse, lastInstr)); // if we have a pk but no ref we create a new instance with the primary key set il.Insert(index++, Instruction.Create(OpCodes.Ldarg_0)); il.Insert( index++, Instruction.Create(OpCodes.Newobj, typeDef.Module.Import(propDef.PropertyType.Resolve().GetConstructors().First()))); il.Insert(index++, Instruction.Create(OpCodes.Stloc_0)); il.Insert(index++, Instruction.Create(OpCodes.Ldloc_0)); il.Insert(index++, Instruction.Create(OpCodes.Ldarg_0)); if (fkPkType.IsValueType) { il.Insert(index++, Instruction.Create(OpCodes.Ldflda, fkField)); il.Insert( index++, Instruction.Create( OpCodes.Call, typeDef.Module.Import( MakeGeneric( fkField.FieldType.Resolve().GetMethods().Single(m => m.Name == "get_Value"), typeDef.Module.Import(fkPkType))))); var fkMapDef = assemblyMapDefinitions.SelectMany(am => am.Value).First(m => m.TypeFullName == columnDef.TypeFullName); var assemblyDef = assemblyDefinitions.Single(ad => ad.Value.FullName == fkMapDef.AssemblyFullName).Value; var fkMapTypeRef = GetTypeDefFromFullName(columnDef.TypeFullName, assemblyDef); il.Insert( index++, Instruction.Create( OpCodes.Callvirt, typeDef.Module.Import( this.GetProperty(fkMapTypeRef, fkMapDef.ColumnDefinitions.Single(cd => cd.IsPrimaryKey).Name).SetMethod))); } else { il.Insert(index++, Instruction.Create(OpCodes.Ldfld, fkField)); var fkMapDef = assemblyMapDefinitions.SelectMany(am => am.Value).First(m => m.TypeFullName == columnDef.TypeFullName); var assemblyDef = assemblyDefinitions.Single(ad => ad.Value.FullName == fkMapDef.AssemblyFullName).Value; var fkMapTypeRef = GetTypeDefFromFullName(columnDef.TypeFullName, assemblyDef); il.Insert( index++, Instruction.Create( OpCodes.Callvirt, typeDef.Module.Import( this.GetProperty(fkMapTypeRef, fkMapDef.ColumnDefinitions.Single(cd => cd.IsPrimaryKey).Name).SetMethod))); } il.Insert(index++, Instruction.Create(OpCodes.Ldloc_0)); il.Insert(index, Instruction.Create(OpCodes.Stfld, backingField)); } }
public List<Tuple<GrainId, string, int>> GetGrainStatistics() { var counts = new Dictionary<string, Dictionary<GrainId, int>>(); lock (activations) { foreach (var activation in activations) { ActivationData data = activation.Value; if (data == null || data.GrainInstance == null) continue; // TODO: generic type expansion var grainTypeName = TypeUtils.GetFullName(data.GrainInstanceType); Dictionary<GrainId, int> grains; int n; if (!counts.TryGetValue(grainTypeName, out grains)) { counts.Add(grainTypeName, new Dictionary<GrainId, int> { { data.Grain, 1 } }); } else if (!grains.TryGetValue(data.Grain, out n)) grains[data.Grain] = 1; else grains[data.Grain] = n + 1; } } return counts .SelectMany(p => p.Value.Select(p2 => Tuple.Create(p2.Key, p.Key, p2.Value))) .ToList(); }
private IEnumerable<DrugExposure> PrepareDrugExposures(IEnumerable<DrugExposure> drugExposures, Dictionary<long, VisitOccurrence> visitOccurrences) { var rxDrugs = new Dictionary<Guid, List<DrugExposure>>(); var medicalDrugs = new Dictionary<Guid, List<DrugExposure>>(); foreach (var drugExposure in drugExposures) { if (drugExposure.TypeConceptId == 38000175 || drugExposure.TypeConceptId == 38000176) { if (!rxDrugs.ContainsKey(drugExposure.SourceRecordGuid)) rxDrugs.Add(drugExposure.SourceRecordGuid, new List<DrugExposure>()); rxDrugs[drugExposure.SourceRecordGuid].Add(drugExposure); continue; } if (!medicalDrugs.ContainsKey(drugExposure.SourceRecordGuid)) medicalDrugs.Add(drugExposure.SourceRecordGuid, new List<DrugExposure>()); medicalDrugs[drugExposure.SourceRecordGuid].Add(drugExposure); } foreach (var sourceRecordGuid in medicalDrugs.Keys) { //TypeConceptId == 0, ndc var ndcExists = medicalDrugs[sourceRecordGuid].Any(d => d.TypeConceptId == 0); foreach (var drugExposure in medicalDrugs[sourceRecordGuid]) { //TypeConceptId == 4, proc_cd if (drugExposure.TypeConceptId == 4 && ndcExists) continue; var visitOccurrence = GetVisitOccurrence(drugExposure); if (visitOccurrence == null) continue; drugExposure.VisitOccurrenceId = visitOccurrence.Id; drugExposure.TypeConceptId = visitOccurrence.ConceptId == 9201 ? 38000180 : 38000179; yield return drugExposure; } } foreach (var similarDrugs in rxDrugs.SelectMany(drugs => drugs.Value.GroupBy(d => d.SourceValue.Length >= 9 ? d.SourceValue.Substring(0, 9) : d.SourceValue))) { if (similarDrugs.Count(d => d.ConceptId > 0) > 0) { yield return similarDrugs.Where(d => d.ConceptId > 0).OrderBy(d => d.SourceValue.Length).Last(); continue; } yield return similarDrugs.OrderBy(d => d.SourceValue.Length).Last(); } }
private void ImplementITrackedEntityForTypeDefinition(TypeDefinition typeDef, MapDefinition mapDefinition, bool notInInheritance, Dictionary<string, AssemblyDefinition> assemblyDefinitions, Dictionary<string, List<MapDefinition>> assemblyMapDefinitions) { if (typeDef.Methods.Any(m => m.Name == "GetDirtyProperties")) { return; // type already woven } if (!this.ImplementsInterface(typeDef, typeof(ITrackedEntity))) { this.AddInterfaceToNonObjectAncestor(typeDef, typeof(ITrackedEntity)); } // some common type definitions var boolTypeDef = typeDef.Module.Import(typeof(bool)); var voidTypeDef = typeDef.Module.Import(typeof(void)); var stringTypeDef = typeDef.Module.Import(typeof(string)); var listStringTypeDef = typeDef.Module.Import(typeof(List<>)).MakeGenericInstanceType(stringTypeDef); var objectTypeDef = typeDef.Module.Import(typeof(object)); // some column names const string isTrackingName = "__isTracking"; // add isTracking field if base class if (this.IsBaseClass(typeDef)) { var _isTrackingField = new FieldDefinition(isTrackingName, FieldAttributes.Family, boolTypeDef); this.MakeNotDebuggerBrowsable(typeDef.Module, _isTrackingField); typeDef.Fields.Add(_isTrackingField); } // fields for tracking state of properties on this class only var nonPkCols = mapDefinition.ColumnDefinitions.Where(c => !c.IsPrimaryKey && c.Relationship != RelationshipType.OneToMany).ToList(); foreach (var columnDefinition in nonPkCols) { if (this.HasPropertyInInheritanceChain(typeDef, columnDefinition.Name)) { var propertyDefinition = this.GetProperty(typeDef, columnDefinition.Name); if (propertyDefinition.DeclaringType.FullName == typeDef.FullName) { var dirtyField = new FieldDefinition( string.Format("__{0}_IsDirty", columnDefinition.Name), FieldAttributes.Family, boolTypeDef); this.MakeNotDebuggerBrowsable(typeDef.Module, dirtyField); typeDef.Fields.Add(dirtyField); // handle other maps, strings, valuetype, valuetype? var oldValuePropType = propertyDefinition.PropertyType; if (columnDefinition.Relationship == RelationshipType.None && propertyDefinition.PropertyType.IsValueType && propertyDefinition.PropertyType.Name != "Nullable`1") { oldValuePropType = typeDef.Module.Import(typeof(Nullable<>)).MakeGenericInstanceType(oldValuePropType); // use nullable value types } var oldValueField = new FieldDefinition( string.Format("__{0}_OldValue", columnDefinition.Name), FieldAttributes.Family, oldValuePropType); this.MakeNotDebuggerBrowsable(typeDef.Module, oldValueField); typeDef.Fields.Add(oldValueField); } } } // insert the instructions in to the setter var isTrackingField = this.GetField(typeDef, isTrackingName); foreach (var columnDefinition in nonPkCols) { if (this.HasPropertyInInheritanceChain(typeDef, columnDefinition.Name)) { var propertyDefinition = this.GetProperty(typeDef, columnDefinition.Name); if (propertyDefinition.DeclaringType.FullName == typeDef.FullName) { var backingField = this.GetBackingField(propertyDefinition); var setter = propertyDefinition.SetMethod; setter.Body.Variables.Add(new VariableDefinition(boolTypeDef)); // we need a local bool setter.Body.InitLocals = true; var setIl = setter.Body.Instructions; var setIntructions = new List<Instruction>(); setIntructions.Add(Instruction.Create(OpCodes.Nop)); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_0)); setIntructions.Add(Instruction.Create(OpCodes.Ldfld, isTrackingField)); setIntructions.Add(Instruction.Create(OpCodes.Ldc_I4_0)); setIntructions.Add(Instruction.Create(OpCodes.Ceq)); setIntructions.Add(Instruction.Create(OpCodes.Stloc_0)); setIntructions.Add(Instruction.Create(OpCodes.Ldloc_0)); var endNopInstr = Instruction.Create(OpCodes.Nop); var endLdArgInstr = setIl.First(); setIntructions.Add(Instruction.Create(OpCodes.Brtrue, endLdArgInstr)); setIntructions.Add(Instruction.Create(OpCodes.Nop)); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_0)); setIntructions.Add( Instruction.Create( OpCodes.Ldfld, typeDef.Fields.Single(f => f.Name == string.Format("__{0}_IsDirty", columnDefinition.Name)))); setIntructions.Add(Instruction.Create(OpCodes.Stloc_0)); setIntructions.Add(Instruction.Create(OpCodes.Ldloc_0)); setIntructions.Add(Instruction.Create(OpCodes.Brtrue, endNopInstr)); setIntructions.Add(Instruction.Create(OpCodes.Nop)); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_0)); if (propertyDefinition.PropertyType.IsValueType) { var isEnum = propertyDefinition.PropertyType.Resolve().IsEnum; if (isEnum) { setIntructions.Add(Instruction.Create(OpCodes.Ldfld, backingField)); setIntructions.Add(Instruction.Create(OpCodes.Box, propertyDefinition.PropertyType)); } else { setIntructions.Add(Instruction.Create(OpCodes.Ldflda, backingField)); } setIntructions.Add(Instruction.Create(OpCodes.Ldarg_1)); if (isEnum) { setIntructions.Add(Instruction.Create(OpCodes.Box, propertyDefinition.PropertyType)); setIntructions.Add( Instruction.Create( OpCodes.Callvirt, typeDef.Module.Import( objectTypeDef.Resolve() .GetMethods() .Single( m => m.Name == "Equals" && m.Parameters.Count == 1 && m.Parameters.First().ParameterType.Name.ToLowerInvariant() == "object")))); } else if (propertyDefinition.PropertyType.Name == "Nullable`1") { setIntructions.Add(Instruction.Create(OpCodes.Box, backingField.FieldType)); setIntructions.Add(Instruction.Create(OpCodes.Constrained, backingField.FieldType)); setIntructions.Add( Instruction.Create( OpCodes.Callvirt, typeDef.Module.Import( objectTypeDef.Resolve() .GetMethods() .Single( m => m.Name == "Equals" && m.Parameters.Count == 1 && m.Parameters.First().ParameterType.Name.ToLowerInvariant() == "object")))); } else { setIntructions.Add( Instruction.Create( OpCodes.Call, typeDef.Module.Import( propertyDefinition.PropertyType.Resolve() .Methods.Single( m => m.Name == "Equals" && m.Parameters.Count == 1 && m.Parameters.First().ParameterType.Name.ToLowerInvariant() != "object")))); } setIntructions.Add(Instruction.Create(OpCodes.Stloc_0)); setIntructions.Add(Instruction.Create(OpCodes.Ldloc_0)); setIntructions.Add(Instruction.Create(OpCodes.Brtrue, endNopInstr)); } else { var fkPkType = columnDefinition.DbType.GetCLRType(); TypeReference fkTypeReference; if (fkPkType.IsValueType) { fkTypeReference = typeDef.Module.Import(typeof(Nullable<>).MakeGenericType(fkPkType)); } else { fkTypeReference = typeDef.Module.Import(fkPkType); } setIntructions.Add(Instruction.Create(OpCodes.Ldfld, backingField)); var hmmInstr = Instruction.Create(OpCodes.Ldc_I4_0); var hmmInstr2 = Instruction.Create(OpCodes.Ldc_I4_1); if (propertyDefinition.PropertyType.Name.ToLowerInvariant() == "string") { var orInstr = Instruction.Create(OpCodes.Ldarg_0); setIntructions.Add(Instruction.Create(OpCodes.Brtrue, orInstr)); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_1)); setIntructions.Add(Instruction.Create(OpCodes.Brtrue, hmmInstr)); setIntructions.Add(orInstr); } else { var orInstr = Instruction.Create(OpCodes.Ldarg_1); var orInstr2 = Instruction.Create(OpCodes.Ldarg_0); setIntructions.Add(Instruction.Create(OpCodes.Brtrue, orInstr)); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_1)); setIntructions.Add(Instruction.Create(OpCodes.Brtrue, hmmInstr)); setIntructions.Add(orInstr); setIntructions.Add(Instruction.Create(OpCodes.Brtrue, orInstr2)); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_0)); if (fkPkType.IsValueType) { // need to call HasValue setIntructions.Add(Instruction.Create(OpCodes.Ldflda, typeDef.Fields.Single(f => f.Name == columnDefinition.DbName))); setIntructions.Add(Instruction.Create( OpCodes.Call, MakeGeneric( typeDef.Module.Import(fkTypeReference.Resolve().GetMethods().Single(m => m.Name == "get_HasValue")), typeDef.Module.Import(fkPkType)))); setIntructions.Add(Instruction.Create(OpCodes.Brtrue, hmmInstr)); } else { // check for null setIntructions.Add(Instruction.Create(OpCodes.Ldfld, typeDef.Fields.Single(f => f.Name == columnDefinition.DbName))); setIntructions.Add(Instruction.Create(OpCodes.Brtrue, hmmInstr)); } setIntructions.Add(orInstr2); } setIntructions.Add(Instruction.Create(OpCodes.Ldfld, backingField)); setIntructions.Add(Instruction.Create(OpCodes.Brfalse, hmmInstr2)); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_0)); setIntructions.Add(Instruction.Create(OpCodes.Ldfld, backingField)); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_1)); if (propertyDefinition.PropertyType.Name.ToLowerInvariant() == "string") { setIntructions.Add( Instruction.Create( OpCodes.Callvirt, typeDef.Module.Import( propertyDefinition.PropertyType.Resolve() .GetMethods() .Single( m => m.Name == "Equals" && m.Parameters.Count == 1 && m.Parameters.First().ParameterType.Name.ToLowerInvariant() == "string")))); } else { setIntructions.Add( Instruction.Create( OpCodes.Callvirt, typeDef.Module.Import( objectTypeDef.Resolve() .GetMethods() .Single( m => m.Name == "Equals" && m.Parameters.Count == 1 && m.Parameters.First().ParameterType.Name.ToLowerInvariant() == "object")))); } var nopInstr = Instruction.Create(OpCodes.Nop); setIntructions.Add(Instruction.Create(OpCodes.Br, nopInstr)); setIntructions.Add(hmmInstr2); setIntructions.Add(nopInstr); var nopInstr2 = Instruction.Create(OpCodes.Nop); setIntructions.Add(Instruction.Create(OpCodes.Br, nopInstr2)); setIntructions.Add(hmmInstr); setIntructions.Add(nopInstr2); setIntructions.Add(Instruction.Create(OpCodes.Stloc_0)); setIntructions.Add(Instruction.Create(OpCodes.Ldloc_0)); setIntructions.Add(Instruction.Create(OpCodes.Brtrue, endNopInstr)); setIntructions.Add(Instruction.Create(OpCodes.Nop)); } // it's now dirty setIntructions.Add(Instruction.Create(OpCodes.Nop)); var topOfSetIsDirtyInstr = Instruction.Create(OpCodes.Ldarg_0); if (columnDefinition.Relationship == RelationshipType.ManyToOne || columnDefinition.Relationship == RelationshipType.OneToOne) { // we need to check whether the foreign key backing field has a value var setToBackingFieldInstr = Instruction.Create(OpCodes.Ldarg_0); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_0)); setIntructions.Add(Instruction.Create(OpCodes.Ldfld, backingField)); setIntructions.Add(Instruction.Create(OpCodes.Brtrue, setToBackingFieldInstr)); var fkPkType = columnDefinition.DbType.GetCLRType(); TypeReference fkTypeReference; if (fkPkType.IsValueType) { fkTypeReference = typeDef.Module.Import(typeof(Nullable<>).MakeGenericType(fkPkType)); } else { fkTypeReference = typeDef.Module.Import(fkPkType); } var fkField = typeDef.Fields.Single(f => f.Name == columnDefinition.DbName); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_0)); if (fkPkType.IsValueType) { // need to call HasValue setIntructions.Add(Instruction.Create(OpCodes.Ldflda, fkField)); setIntructions.Add(Instruction.Create( OpCodes.Call, MakeGeneric( typeDef.Module.Import(fkTypeReference.Resolve().GetMethods().Single(m => m.Name == "get_HasValue")), typeDef.Module.Import(fkPkType)))); setIntructions.Add(Instruction.Create(OpCodes.Brfalse, setToBackingFieldInstr)); } else { // check for null setIntructions.Add(Instruction.Create(OpCodes.Ldfld, fkField)); setIntructions.Add(Instruction.Create(OpCodes.Brfalse, setToBackingFieldInstr)); } // need to add a variable to hold the new obj var fkGeneratedVariableDef = new VariableDefinition(propertyDefinition.PropertyType); propertyDefinition.SetMethod.Body.Variables.Add(fkGeneratedVariableDef); // if we get here then we have an FK value but null in this backing field so we need to create a new instance of the FK and set that as the old value setIntructions.Add(Instruction.Create(OpCodes.Ldarg_0)); setIntructions.Add(Instruction.Create(OpCodes.Newobj, typeDef.Module.Import(propertyDefinition.PropertyType.Resolve().GetConstructors().First()))); setIntructions.Add(Instruction.Create(OpCodes.Stloc, fkGeneratedVariableDef)); setIntructions.Add(Instruction.Create(OpCodes.Ldloc, fkGeneratedVariableDef)); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_0)); if (fkPkType.IsValueType) { setIntructions.Add(Instruction.Create(OpCodes.Ldflda, typeDef.Fields.Single(f => f.Name == columnDefinition.DbName))); setIntructions.Add(Instruction.Create( OpCodes.Call, typeDef.Module.Import( MakeGeneric( fkField.FieldType.Resolve().GetMethods().Single(m => m.Name == "get_Value"), typeDef.Module.Import(fkPkType))))); var fkMapDef = assemblyMapDefinitions.SelectMany(am => am.Value).First(m => m.TypeFullName == columnDefinition.TypeFullName); var assemblyDef = assemblyDefinitions.Single(ad => ad.Value.FullName == fkMapDef.AssemblyFullName).Value; var fkMapTypeRef = GetTypeDefFromFullName(columnDefinition.TypeFullName, assemblyDef); setIntructions.Add( Instruction.Create( OpCodes.Callvirt, typeDef.Module.Import( this.GetProperty(fkMapTypeRef, fkMapDef.ColumnDefinitions.Single(cd => cd.IsPrimaryKey).Name).SetMethod))); } else { setIntructions.Add(Instruction.Create(OpCodes.Ldfld, fkField)); var fkMapDef = assemblyMapDefinitions.SelectMany(am => am.Value).First(m => m.TypeFullName == columnDefinition.TypeFullName); var assemblyDef = assemblyDefinitions.Single(ad => ad.Value.FullName == fkMapDef.AssemblyFullName).Value; var fkMapTypeRef = GetTypeDefFromFullName(columnDefinition.TypeFullName, assemblyDef); setIntructions.Add(Instruction.Create( OpCodes.Callvirt, typeDef.Module.Import( this.GetProperty(fkMapTypeRef, fkMapDef.ColumnDefinitions.Single(cd => cd.IsPrimaryKey).Name).SetMethod))); } setIntructions.Add(Instruction.Create(OpCodes.Ldloc, fkGeneratedVariableDef)); setIntructions.Add(Instruction.Create(OpCodes.Stfld, typeDef.Fields.Single(f => f.Name == string.Format("__{0}_OldValue", columnDefinition.Name)))); setIntructions.Add(Instruction.Create(OpCodes.Br, topOfSetIsDirtyInstr)); // set using backing field setIntructions.Add(setToBackingFieldInstr); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_0)); setIntructions.Add(Instruction.Create(OpCodes.Ldfld, backingField)); setIntructions.Add( Instruction.Create( OpCodes.Stfld, typeDef.Fields.Single(f => f.Name == string.Format("__{0}_OldValue", columnDefinition.Name)))); } else { setIntructions.Add(Instruction.Create(OpCodes.Ldarg_0)); setIntructions.Add(Instruction.Create(OpCodes.Ldarg_0)); setIntructions.Add(Instruction.Create(OpCodes.Ldfld, backingField)); if (columnDefinition.Relationship == RelationshipType.None && propertyDefinition.PropertyType.IsValueType && propertyDefinition.PropertyType.Name != "Nullable`1") { setIntructions.Add( Instruction.Create( OpCodes.Newobj, MakeGeneric( typeDef.Module.Import( typeDef.Fields.Single(f => f.Name == string.Format("__{0}_OldValue", columnDefinition.Name)) .FieldType.Resolve() .GetConstructors() .First()), propertyDefinition.PropertyType))); } setIntructions.Add( Instruction.Create( OpCodes.Stfld, typeDef.Fields.Single(f => f.Name == string.Format("__{0}_OldValue", columnDefinition.Name)))); } setIntructions.Add(topOfSetIsDirtyInstr); setIntructions.Add(Instruction.Create(OpCodes.Ldc_I4_1)); setIntructions.Add( Instruction.Create( OpCodes.Stfld, typeDef.Fields.Single(f => f.Name == string.Format("__{0}_IsDirty", columnDefinition.Name)))); setIntructions.Add(Instruction.Create(OpCodes.Nop)); setIntructions.Add(endNopInstr); setIntructions.Reverse(); foreach (var instruction in setIntructions) { setIl.Insert(0, instruction); } } } } // implement the ITrackedEntity methods // EnableTracking if (this.IsBaseClass(typeDef)) { var enableTracking = new MethodDefinition( "EnableTracking", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final, voidTypeDef); enableTracking.Body.Instructions.Add(Instruction.Create(OpCodes.Nop)); enableTracking.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0)); enableTracking.Body.Instructions.Add(Instruction.Create(OpCodes.Ldc_I4_1)); enableTracking.Body.Instructions.Add(Instruction.Create(OpCodes.Stfld, typeDef.Fields.Single(f => f.Name == isTrackingName))); enableTracking.Body.Instructions.Add(Instruction.Create(OpCodes.Ret)); typeDef.Methods.Add(enableTracking); } // DisableTracking var disableTrackingMethodAttrs = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual; if (notInInheritance) { disableTrackingMethodAttrs = disableTrackingMethodAttrs | MethodAttributes.NewSlot | MethodAttributes.Final; } var disableTracking = new MethodDefinition("DisableTracking", disableTrackingMethodAttrs, voidTypeDef); var disableInstructions = disableTracking.Body.Instructions; disableInstructions.Add(Instruction.Create(OpCodes.Nop)); disableInstructions.Add(Instruction.Create(OpCodes.Ldarg_0)); disableInstructions.Add(Instruction.Create(OpCodes.Ldc_I4_0)); disableInstructions.Add(Instruction.Create(OpCodes.Stfld, isTrackingField)); foreach (var col in nonPkCols) { if (this.HasPropertyInInheritanceChain(typeDef, col.Name)) { var propDef = this.GetProperty(typeDef, col.Name); // reset isdirty disableInstructions.Add(Instruction.Create(OpCodes.Ldarg_0)); disableInstructions.Add(Instruction.Create(OpCodes.Ldc_I4_0)); disableInstructions.Add(Instruction.Create(OpCodes.Stfld, this.GetField(typeDef, string.Format("__{0}_IsDirty", col.Name)))); // reset oldvalue disableInstructions.Add(Instruction.Create(OpCodes.Ldarg_0)); var oldValueField = this.GetField(typeDef, string.Format("__{0}_OldValue", col.Name)); if (propDef.PropertyType.IsValueType) { disableInstructions.Add(Instruction.Create(OpCodes.Ldflda, oldValueField)); disableInstructions.Add(Instruction.Create(OpCodes.Initobj, oldValueField.FieldType)); } else { disableInstructions.Add(Instruction.Create(OpCodes.Ldnull)); disableInstructions.Add(Instruction.Create(OpCodes.Stfld, oldValueField)); } } } disableInstructions.Add(Instruction.Create(OpCodes.Ret)); typeDef.Methods.Add(disableTracking); // IsTrackingEnabled if (this.IsBaseClass(typeDef)) { var isTrackingEnabled = new MethodDefinition( "IsTrackingEnabled", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final, boolTypeDef); isTrackingEnabled.Body.Instructions.Add(Instruction.Create(OpCodes.Nop)); isTrackingEnabled.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0)); isTrackingEnabled.Body.Instructions.Add(Instruction.Create(OpCodes.Ldfld, typeDef.Fields.Single(f => f.Name == isTrackingName))); isTrackingEnabled.Body.Instructions.Add(Instruction.Create(OpCodes.Stloc_0)); var loadInstr = Instruction.Create(OpCodes.Ldloc_0); isTrackingEnabled.Body.Instructions.Add(Instruction.Create(OpCodes.Br, loadInstr)); isTrackingEnabled.Body.Instructions.Add(loadInstr); isTrackingEnabled.Body.Instructions.Add(Instruction.Create(OpCodes.Ret)); isTrackingEnabled.Body.InitLocals = true; isTrackingEnabled.Body.Variables.Add(new VariableDefinition(boolTypeDef)); typeDef.Methods.Add(isTrackingEnabled); } // GetDirtyProperties var getDirtyPropertiesMethodAttrs = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual; if (notInInheritance) { getDirtyPropertiesMethodAttrs = getDirtyPropertiesMethodAttrs | MethodAttributes.NewSlot | MethodAttributes.Final; } var getDirtyProperties = new MethodDefinition( "GetDirtyProperties", getDirtyPropertiesMethodAttrs, typeDef.Module.Import(typeof(IEnumerable<>)).MakeGenericInstanceType(stringTypeDef)); getDirtyProperties.Body.Variables.Add(new VariableDefinition("dirtyProps", listStringTypeDef)); getDirtyProperties.Body.Variables.Add( new VariableDefinition(typeDef.Module.Import(typeof(IEnumerable<>)).MakeGenericInstanceType(stringTypeDef))); getDirtyProperties.Body.Variables.Add(new VariableDefinition(boolTypeDef)); getDirtyProperties.Body.InitLocals = true; var instructions = getDirtyProperties.Body.Instructions; instructions.Add(Instruction.Create(OpCodes.Nop)); var listStringContruictor = MakeGeneric( typeDef.Module.Import(listStringTypeDef.Resolve().GetConstructors().First(c => !c.HasParameters && !c.IsStatic && c.IsPublic)), stringTypeDef); instructions.Add(Instruction.Create(OpCodes.Newobj, listStringContruictor)); instructions.Add(Instruction.Create(OpCodes.Stloc_0)); var breakToInstruction = Instruction.Create(nonPkCols.Count == 1 ? OpCodes.Ldloc_0 : OpCodes.Ldarg_0); var addMethod = typeDef.Module.Import(listStringTypeDef.Resolve().Methods.Single(m => m.Name == "Add")); addMethod = MakeGeneric(addMethod, stringTypeDef); var visibleCols = nonPkCols.Where(c => this.HasPropertyInInheritanceChain(typeDef, c.Name)).ToList(); for (var i = 0; i < visibleCols.Count; i++) { if (i == 0) { instructions.Add(Instruction.Create(OpCodes.Ldarg_0)); } instructions.Add( Instruction.Create(OpCodes.Ldfld, this.GetField(typeDef, string.Format("__{0}_IsDirty", visibleCols.ElementAt(i).Name)))); instructions.Add(Instruction.Create(OpCodes.Ldc_I4_0)); instructions.Add(Instruction.Create(OpCodes.Ceq)); instructions.Add(Instruction.Create(OpCodes.Stloc_2)); instructions.Add(Instruction.Create(OpCodes.Ldloc_2)); instructions.Add(Instruction.Create(OpCodes.Brtrue, breakToInstruction)); instructions.Add(Instruction.Create(OpCodes.Nop)); instructions.Add(Instruction.Create(OpCodes.Ldloc_0)); instructions.Add(Instruction.Create(OpCodes.Ldstr, visibleCols.ElementAt(i).Name)); instructions.Add(Instruction.Create(OpCodes.Callvirt, addMethod)); instructions.Add(Instruction.Create(OpCodes.Nop)); instructions.Add(Instruction.Create(OpCodes.Nop)); instructions.Add(breakToInstruction); breakToInstruction = Instruction.Create(i == visibleCols.Count - 2 ? OpCodes.Ldloc_0 : OpCodes.Ldarg_0); } instructions.Add(Instruction.Create(OpCodes.Stloc_1)); var retInstr = Instruction.Create(OpCodes.Ldloc_1); instructions.Add(Instruction.Create(OpCodes.Br, retInstr)); instructions.Add(retInstr); instructions.Add(Instruction.Create(OpCodes.Ret)); typeDef.Methods.Add(getDirtyProperties); // GetOldValue var getOldValueMethodAttrs = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual; if (notInInheritance) { getOldValueMethodAttrs = getOldValueMethodAttrs | MethodAttributes.NewSlot | MethodAttributes.Final; } var getOldValue = new MethodDefinition("GetOldValue", getOldValueMethodAttrs, objectTypeDef); getOldValue.Parameters.Add(new ParameterDefinition("propertyName", ParameterAttributes.None, stringTypeDef)); getOldValue.Body.Variables.Add(new VariableDefinition(objectTypeDef)); getOldValue.Body.Variables.Add(new VariableDefinition(stringTypeDef)); getOldValue.Body.Variables.Add(new VariableDefinition(boolTypeDef)); getOldValue.Body.InitLocals = true; var getBodyInstructions = getOldValue.Body.Instructions; getBodyInstructions.Add(Instruction.Create(OpCodes.Nop)); getBodyInstructions.Add(Instruction.Create(OpCodes.Ldarg_1)); getBodyInstructions.Add(Instruction.Create(OpCodes.Stloc_1)); getBodyInstructions.Add(Instruction.Create(OpCodes.Ldloc_1)); var throwExceptionTarget = Instruction.Create(OpCodes.Ldstr, "propertyName"); var returnTarget = Instruction.Create(OpCodes.Ldloc_0); getBodyInstructions.Add(Instruction.Create(OpCodes.Brfalse, throwExceptionTarget)); var switchInstructions = new List<Instruction>(); var opEqualityRef = typeDef.Module.Import(typeof(string).GetMethods().Single(m => m.Name == "op_Equality")); for (var i = 0; i < visibleCols.Count; i++) { // generate the switch bit getBodyInstructions.Add(Instruction.Create(OpCodes.Ldloc_1)); getBodyInstructions.Add(Instruction.Create(OpCodes.Ldstr, visibleCols.ElementAt(i).Name)); getBodyInstructions.Add(Instruction.Create(OpCodes.Call, opEqualityRef)); // generate the if bit var targetInstr = Instruction.Create(OpCodes.Ldarg_0); getBodyInstructions.Add(Instruction.Create(OpCodes.Brtrue, targetInstr)); switchInstructions.Add(targetInstr); switchInstructions.Add( Instruction.Create(OpCodes.Ldfld, this.GetField(typeDef, String.Format("__{0}_IsDirty", visibleCols.ElementAt(i).Name)))); switchInstructions.Add(Instruction.Create(OpCodes.Ldc_I4_0)); switchInstructions.Add(Instruction.Create(OpCodes.Ceq)); switchInstructions.Add(Instruction.Create(OpCodes.Stloc_2)); switchInstructions.Add(Instruction.Create(OpCodes.Ldloc_2)); // generate the return bit var breakInstruction = Instruction.Create(OpCodes.Br, throwExceptionTarget); switchInstructions.Add(Instruction.Create(OpCodes.Brtrue, breakInstruction)); switchInstructions.Add(Instruction.Create(OpCodes.Nop)); switchInstructions.Add(Instruction.Create(OpCodes.Ldarg_0)); switchInstructions.Add( Instruction.Create(OpCodes.Ldfld, this.GetField(typeDef, String.Format("__{0}_OldValue", visibleCols.ElementAt(i).Name)))); if (this.GetProperty(typeDef, visibleCols.ElementAt(i).Name).PropertyType.IsValueType) { switchInstructions.Add( Instruction.Create( OpCodes.Box, this.GetField(typeDef, String.Format("__{0}_OldValue", visibleCols.ElementAt(i).Name)).FieldType)); } switchInstructions.Add(Instruction.Create(OpCodes.Stloc_0)); switchInstructions.Add(Instruction.Create(OpCodes.Br, returnTarget)); switchInstructions.Add(breakInstruction); } // add a br getBodyInstructions.Add(Instruction.Create(OpCodes.Br, throwExceptionTarget)); // run them foreach (var instruction in switchInstructions) { getBodyInstructions.Add(instruction); } // handle the exception getBodyInstructions.Add(Instruction.Create(OpCodes.Nop)); getBodyInstructions.Add(throwExceptionTarget); getBodyInstructions.Add( Instruction.Create(OpCodes.Ldstr, "Either the property doesn't exist or it's not dirty. Consult GetDirtyProperties first")); getBodyInstructions.Add( Instruction.Create( OpCodes.Newobj, typeDef.Module.Import( typeof(ArgumentOutOfRangeException).GetConstructors() .First( c => c.GetParameters().All(p => p.ParameterType == typeof(string)) && c.GetParameters().Count() == 2)))); getBodyInstructions.Add(Instruction.Create(OpCodes.Throw)); getBodyInstructions.Add(returnTarget); getBodyInstructions.Add(Instruction.Create(OpCodes.Ret)); typeDef.Methods.Add(getOldValue); }
public IList<TestataSollecitoDTO> GetSolleciti(int? idEsercizio, Dictionary<int, TipoIndirizzo> idCondomini, bool groupByPersone, DateTime? dataRate, DateTime? dataVersamenti, decimal? importoLimite, decimal? importoCompetenza, DateTime dataSollecito, bool stampaProprietario, int? idBanca, int idModelloLettera, string testoModelloLettera, DateTime? dataRegistrazioneContabile, int? idConto, int? idSottoConto, bool storico, bool sollecitaProprietarioConduzione) { try { var solleciti = new List<TestataSollecitoDTO>(idCondomini.Count); var listaSolleciti = new List<Sollecito>(idCondomini.Count); Esercizio esercizio = null; if (idEsercizio != null) esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio.Value, false); var dataFinale = new DateTime(DateTime.Today.Year, 12, 31); var modello = _daoFactory.GetModelloLetteraTestoDao().Find(idModelloLettera, false); // ========================================================================================== // Leggo subito tutti i soggetti le rate e i versamenti // ========================================================================================== var idCondominiList = idCondomini.Select(item => item.Key).ToList(); // rate var rateSoggetti = !groupByPersone ? _daoFactory.GetRataSoggettoDao().GetByEsercizioSoggetti(idEsercizio, null, idCondominiList, dataRate) : _daoFactory.GetRataSoggettoDao().GetByEsercizioPersone(idEsercizio, null, idCondominiList, dataRate); // soggetti IList<SoggettoCondominio> soggetti = null; IList<SoggettoCondominio> soggettiStampa = null; IList<Persona> persone = null; if (!groupByPersone) soggetti = _daoFactory.GetSoggettoCondominioDao().GetAttiviByEsercizioSoggetti(esercizio, idCondominiList); else { persone = _daoFactory.GetPersonaDao().GetAttiviByEsercizioSoggetti(esercizio, idCondominiList); soggettiStampa = esercizio != null ? _daoFactory.GetSoggettoCondominioDao().GetAttiviByEsercizio(esercizio, dataFinale) : _daoFactory.GetSoggettoCondominioDao().GetAttiviByAzienda(modello.Azienda.ID); } // versamenti IList<VersamentoSoggetto> versamentiSoggetto; IList<VersamentiRate> versamentiRate; if (!groupByPersone) { versamentiSoggetto = _daoFactory.GetVersamentoSoggettoDao().GetByEsercizioSoggetti(idEsercizio, idCondominiList); versamentiRate = _daoFactory.GetVersamentiRateDao().GetByEsercizioSoggetti(idEsercizio, idCondominiList); } else { versamentiSoggetto = _daoFactory.GetVersamentoSoggettoDao().GetByEsercizioPersone(idEsercizio, idCondominiList); versamentiRate = _daoFactory.GetVersamentiRateDao().GetByEsercizioPersone(idEsercizio, idCondominiList); } DatiBancariCondomini bancaSollecito = null; if (idBanca != null) bancaSollecito = _daoFactory.GetDatiBancariCondominiDao().Find(idBanca.Value, false); // ========================================================================================== // Loop per i soggetti per generare i dati di stampa // ========================================================================================== foreach (var kvp in idCondomini) { var id = kvp.Key; try { SoggettoCondominio soggetto = null; Persona persona = null; if (soggetti != null) soggetto = soggetti.FirstOrDefault(item => item.ID == kvp.Key) ?? _daoFactory.GetSoggettoCondominioDao().Find(id, false); else if (persone != null) persona = persone.FirstOrDefault(item => item.ID == kvp.Key) ?? _daoFactory.GetPersonaDao().Find(id, false); if (persona == null && soggetto == null) { _log.ErrorFormat("Non trovata persona/soggetto - {0} - id:{1} - idCondomini:{2}", Utility.GetMethodDescription(), id, idEsercizio.GetValueOrDefault(), idCondomini != null ? string.Join(",", idCondomini.SelectMany(item => item.Key.ToString())) : "<NULL>"); continue; } var rateScadute = !groupByPersone ? rateSoggetti.Where(item => item.Soggetto.ID == kvp.Key).ToList() : rateSoggetti.Where(item => item.Soggetto.Persona.ID == kvp.Key).ToList(); // ----------------------------- // Calcolo importi // ----------------------------- var importoScaduto = rateScadute.Sum(rata => rata.Importo); var importoVersato = rateScadute.Sum(rata => rata.GetImportoVersato(dataVersamenti)); decimal importoVersatoSenzaRata; IList<VersamentoSoggetto> altriVersamenti; IList<VersamentiRate> altriVersamentiRate; if (soggetto != null) { altriVersamenti = versamentiSoggetto.Where(item => item.Soggetto.ID == kvp.Key).ToList(); altriVersamentiRate = versamentiRate.Where(item => item.Versamento.Soggetto.ID == kvp.Key).ToList(); importoVersatoSenzaRata = altriVersamenti.Sum(versamento => versamento.Importo) - altriVersamentiRate.Sum(item => item.Importo); } else { altriVersamenti = versamentiSoggetto.Where(item => item.Soggetto.Persona.ID == kvp.Key).ToList(); altriVersamentiRate = versamentiRate.Where(item => item.Versamento.Soggetto.Persona.ID == kvp.Key).ToList(); importoVersatoSenzaRata = altriVersamenti.Sum(versamento => versamento.Importo) - altriVersamentiRate.Sum(item => item.Importo); } var importoDaSollecitare = importoScaduto - importoVersato - importoVersatoSenzaRata; if (importoLimite == null || Math.Abs(importoDaSollecitare) >= importoLimite.Value) { if (persona == null) persona = soggetto.Persona; var condominio = soggetto != null ? soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento : persona.SoggettiCondominio.Select(item => item.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento).FirstOrDefault(); var recapito = _personaService.GetRecapito(persona, kvp.Value); if (bancaSollecito == null) bancaSollecito = condominio.DatiBancariPrincipale; var testata = new TestataSollecitoDTO { Nominativo = getNominativoPresso(persona, soggetto, recapito), Indirizzo = recapito != null ? recapito.GetIndirizzoCompleto() : string.Empty, Cap = recapito.Cap, Comune = recapito.ComuneDisplayName, Titolo = Decodifica.Instance.GetElement("TitoloPersona", persona.Titolo).Descrizione, ImportoCompetenza = importoCompetenza, DataLettera = dataSollecito, DataRate = dataRate.GetValueOrDefault(), StampaProprietario = stampaProprietario, GroupByPersona = groupByPersone, OggettoLettera = string.IsNullOrEmpty(modello.Oggetto) ? string.Empty : modello.Oggetto.Trim(), TestoLettera = formattaTestoLettera(condominio, bancaSollecito, string.IsNullOrEmpty(testoModelloLettera) ? modello.Testo : testoModelloLettera.Trim()), }; if (soggetto != null) { testata.Id = soggetto.ID; testata.IdSoggettoCondominio = soggetto.ID; testata.IdPersona = soggetto.Persona.ID; testata.IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID; testata.Interno = soggetto.UnitaImmobiliare.InternoCompleto; testata.Piano = soggetto.UnitaImmobiliare.Piano; testata.Ordine = soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(); testata.DescrizioneUnitaImmobiliare = soggetto.UnitaImmobiliare.Descrizione; testata.Subalterno = soggetto.UnitaImmobiliare.Subalterno; } else if (persona != null) { testata.Id = persona.ID; testata.IdPersona = persona.ID; } var righeCondominio = condominio.IndirizzoCompleto.Split('&'); testata.DescrizioneCompletaCondominio = $"Condominio: {righeCondominio[0]}{Environment.NewLine}{righeCondominio[1]} - {righeCondominio[2]} - {righeCondominio[3]}"; // Se la stampa è per persona e viee richiesta la stampa per conoscenza al proprietario occorre leggere il soggettocondominio (soggettoStampa) bugid#8573 var soggettoStampa = soggetto; if (soggettoStampa == null && persona != null) soggettoStampa = soggettiStampa.Where(item => item.Persona.ID == persona.ID).OrderBy(item => item.UnitaImmobiliare.TipoUnitaImmobiliare.ID).FirstOrDefault(); if (stampaProprietario && soggettoStampa != null && soggettoStampa.Tipo == TipoSoggetto.Conduttore) { var proprietario = soggettoStampa.UnitaImmobiliare.GetProprietarioPrincipale(dataFinale) ?? soggettoStampa.UnitaImmobiliare.Proprietari.OrderByDescending(item => item.DataInizio.GetValueOrDefault()).FirstOrDefault(); if (proprietario != null) testata.NominativoProprietario = proprietario.DisplayName; if (proprietario != null) { var recapitoProprietario = _personaService.GetRecapito(proprietario.Persona, kvp.Value); if (recapitoProprietario != null) { testata.IndirizzoProprietario = recapitoProprietario.GetIndirizzoCompleto(); testata.ComuneProprietario = recapitoProprietario.ComuneDisplayName; testata.CapProprietario = recapitoProprietario.Cap; } } } if (recapito.Comune != null) testata.Provincia = recapito.Comune.ProvinciaAppartenenza.Codice; // ---------------------------------------------- // Dettaglio Rate // ---------------------------------------------- decimal importoTotaleDaVersare = 0; // Rate con versamenti foreach (var rata in rateScadute) { try { var dettaglio = new DettaglioSollecitoDTO { Id = rata.ID, DataScadenza = rata.DataScadenza, IdTestataSollecito = testata.Id, ProgressivoRata = rata.PianoRatealeDettaglio?.Progressivo ?? rata.Progressivo, Importo = rata.Importo, ImportoPagato = rata.GetImportoVersato(dataVersamenti), CodiceRata = rata.ID, IdEsercizio = rata.Esercizio.ID, IdSoggetto = rata.Soggetto.ID, DescrizioneSoggetto = rata.Soggetto.DisplayName, DescrizioneEsercizio = rata.Esercizio.DisplayName }; if (groupByPersone) { dettaglio.IdUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.ID; dettaglio.Interno = rata.Soggetto.UnitaImmobiliare.InternoCompleto; dettaglio.Piano = rata.Soggetto.UnitaImmobiliare.Piano; dettaglio.Ordine = rata.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(); dettaglio.DescrizioneUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione + " - " + rata.Soggetto.UnitaImmobiliare.Descrizione; dettaglio.Subalterno = rata.Soggetto.UnitaImmobiliare.Subalterno; } if (soggetto?.PercentualeRiferimento != null) dettaglio.PercentualePossesso = Convert.ToInt32(soggetto.PercentualeRiferimento.Value); dettaglio.ImportoDaVersare = dettaglio.Importo - dettaglio.ImportoPagato; if (rata.Versamenti.Count > 0) dettaglio.DataUltimoPagamento = IesiGenericCollections<VersamentiRate>.GetByIndex(rata.Versamenti, rata.Versamenti.Count - 1).Versamento.Data; testata.Dettagli.Add(dettaglio); importoTotaleDaVersare += dettaglio.ImportoDaVersare; } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel calcolo del sollecito per soggetto - DETTAGLIO RATE CON VERSAMENTI - {0} - soggetto:{1} - rata:{2}", ex, Utility.GetMethodDescription(), id, rata.ID); throw; } } // Versamenti senza rate associate // TODO: elaborare versamenti rate e versamentisoggetto per ottenere una lista dei versamenti fuori piano rateale foreach (var versamento in altriVersamenti) { try { var versamento1 = versamento; var importoPagato = versamento.Importo - altriVersamentiRate.Where(item => item.Versamento.ID == versamento1.ID).Sum(item => item.Importo); if (importoPagato > 0) { var dettaglio = new DettaglioSollecitoDTO { DataScadenza = DateTime.MaxValue, DataUltimoPagamento = versamento.Data, IdTestataSollecito = testata.Id, ImportoPagato = importoPagato, IdEsercizio = versamento.Esercizio.ID, IdSoggetto = versamento.Soggetto.ID, DescrizioneSoggetto = versamento.Soggetto.DisplayName, DescrizioneEsercizio = versamento.Esercizio.DisplayName, ImportoDaVersare = importoPagato * -1 }; if (groupByPersone) { dettaglio.IdUnitaImmobiliare = versamento.Soggetto.UnitaImmobiliare.ID; dettaglio.Interno = versamento.Soggetto.UnitaImmobiliare.InternoCompleto; dettaglio.Piano = versamento.Soggetto.UnitaImmobiliare.Piano; dettaglio.Ordine = versamento.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(); dettaglio.DescrizioneUnitaImmobiliare = versamento.Soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione + " - " + versamento.Soggetto.UnitaImmobiliare.Descrizione; dettaglio.Subalterno = versamento.Soggetto.UnitaImmobiliare.Subalterno; } if (soggetto?.PercentualeRiferimento != null) dettaglio.PercentualePossesso = Convert.ToInt32(soggetto.PercentualeRiferimento.Value); testata.Dettagli.Add(dettaglio); importoTotaleDaVersare -= dettaglio.ImportoPagato; } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel calcolo del sollecito per soggetto - VERSAMENTO SENZA RATE ASSOCIATE - {0} - Id:{1} - versamento:{2}", ex, Utility.GetMethodDescription(), id, versamento.ID); throw; } } testata.ImportoTotaleDaVersare = importoTotaleDaVersare; testata.TipoIndirizzo = kvp.Value; solleciti.Add(testata); // ================================================================================ // Se richiesto aggiungo per i proprietari le rate di conduzione // ================================================================================ if (sollecitaProprietarioConduzione) { if (soggetto != null) { var conduttori = soggetto.UnitaImmobiliare.Conduttori; if (conduttori.Count > 0) { var idConduttori = new List<int>(conduttori.Count); idConduttori.AddRange(conduttori.Select(soggettoCondominio => soggettoCondominio.ID)); var rateConduttori = _rateService.GetRataByEsercizioSoggetti(idEsercizio, idConduttori, dataRate, false); var versamentiConduttori = _versamentiService.GetVersamentiByEsercizioSoggetti(idEsercizio, idConduttori); var importoCompetenzaConduzione = rateConduttori.Sum(item => item.Importo.GetValueOrDefault()); var importoVersatoConduzione = versamentiConduttori.Sum(item => item.Importo); testata.ImportoCompetenza += importoCompetenzaConduzione; testata.ImportoTotaleDaVersare += (importoCompetenzaConduzione - importoVersatoConduzione); // Dettaglio rate IList<VersamentoSoggetto> versamentiElaborati = new List<VersamentoSoggetto>(); foreach (var rataSoggettoDTO in rateConduttori) { var dettaglio = new DettaglioSollecitoDTO { Id = rataSoggettoDTO.ID, DataScadenza = rataSoggettoDTO.DataScadenza, IdTestataSollecito = testata.Id, ProgressivoRata = rataSoggettoDTO.Progressivo, Importo = rataSoggettoDTO.Importo.GetValueOrDefault(), ImportoPagato = rataSoggettoDTO.ImportoPagato.GetValueOrDefault(), CodiceRata = rataSoggettoDTO.ID, IdEsercizio = rataSoggettoDTO.IdEsercizio, IdSoggetto = rataSoggettoDTO.IdSoggettoCondominio, DescrizioneSoggetto = rataSoggettoDTO.DescrizioneSoggettoCondominio, DescrizioneEsercizio = rataSoggettoDTO.DescrizioneEsercizio }; if (groupByPersone) { dettaglio.IdUnitaImmobiliare = rataSoggettoDTO.IdUnitaImmobiliare; dettaglio.Ordine = rataSoggettoDTO.OrdineUnitaImmobiliare; dettaglio.DescrizioneUnitaImmobiliare = rataSoggettoDTO.DescrizioneUnitaImmobiliare; dettaglio.Subalterno = rataSoggettoDTO.Subalterno; } if (soggetto?.PercentualeRiferimento != null) dettaglio.PercentualePossesso = Convert.ToInt32(soggetto.PercentualeRiferimento.Value); dettaglio.ImportoDaVersare = dettaglio.Importo - dettaglio.ImportoPagato; var rata = _daoFactory.GetRataSoggettoDao().Find(rataSoggettoDTO.ID, false); if (rata != null && rata.Versamenti.Count > 0) { foreach (var rateVersamenti in rata.Versamenti) versamentiElaborati.Add(rateVersamenti.Versamento); dettaglio.DataUltimoPagamento = IesiGenericCollections<VersamentiRate>.GetByIndex(rata.Versamenti, rata.Versamenti.Count - 1).Versamento.Data; } testata.Dettagli.Add(dettaglio); } // Versamenti fuori piano rateale foreach (var versamentoSoggetto in versamentiConduttori) { if (!versamentiElaborati.Contains(versamentoSoggetto) && versamentoSoggetto.Importo > 0) { var dettaglioVersamento = new DettaglioSollecitoDTO { DataScadenza = DateTime.MaxValue, DataUltimoPagamento = versamentoSoggetto.Data, IdTestataSollecito = testata.Id, ImportoPagato = versamentoSoggetto.Importo, IdEsercizio = versamentoSoggetto.Esercizio.ID, IdSoggetto = versamentoSoggetto.Soggetto.ID, DescrizioneSoggetto = versamentoSoggetto.Soggetto.DisplayName, DescrizioneEsercizio = versamentoSoggetto.Esercizio.DisplayName, ImportoDaVersare = versamentoSoggetto.Importo * -1 }; if (groupByPersone) { dettaglioVersamento.IdUnitaImmobiliare = versamentoSoggetto.Soggetto.UnitaImmobiliare.ID; dettaglioVersamento.Interno = versamentoSoggetto.Soggetto.UnitaImmobiliare.InternoCompleto; dettaglioVersamento.Piano = versamentoSoggetto.Soggetto.UnitaImmobiliare.Piano; dettaglioVersamento.Ordine = versamentoSoggetto.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(); dettaglioVersamento.DescrizioneUnitaImmobiliare = versamentoSoggetto.Soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione + " - " + versamentoSoggetto.Soggetto.UnitaImmobiliare.Descrizione; dettaglioVersamento.Subalterno = versamentoSoggetto.Soggetto.UnitaImmobiliare.Subalterno; } testata.Dettagli.Add(dettaglioVersamento); } } } } } // ================================================================ // Creo gli oggetti sollecito se richiesto // ================================================================ if (storico) { var esercizioSollecito = (esercizio ?? _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(condominio, DateTime.Today)) ?? _esercizioService.GetUltimoEsercizioOrdinario(condominio.ID); if (esercizioSollecito != null) { Sollecito sollecito; var testoLettera = testoModelloLettera; if (string.IsNullOrEmpty(testoLettera)) testoLettera = modello.Testo; if (!string.IsNullOrEmpty(testoLettera)) testoLettera = testoLettera.Trim(); if (soggetto != null) { sollecito = new Sollecito(esercizioSollecito, soggetto, dataSollecito, dataRate.GetValueOrDefault(), importoLimite.GetValueOrDefault(), testata.ImportoTotaleDaVersare, bancaSollecito, modello.Oggetto, testoLettera) { ImportoCompetenza = importoCompetenza, TipoIndirizzo = kvp.Value, StampaProprietario = stampaProprietario, GroupByPersona = groupByPersone }; } else { sollecito = new Sollecito(esercizioSollecito, persona, dataSollecito, dataRate.GetValueOrDefault(), importoLimite.GetValueOrDefault(), testata.ImportoTotaleDaVersare, bancaSollecito, modello.Oggetto, testoLettera) { ImportoCompetenza = importoCompetenza, TipoIndirizzo = kvp.Value, StampaProprietario = stampaProprietario, GroupByPersona = groupByPersone }; } foreach (var dett in testata.Dettagli) { var dettaglio = new DettaglioSollecito(sollecito, dett.Importo, dett.ImportoDaVersare, dett.ImportoPagato) { DataUltimoPagamento = dett.DataUltimoPagamento }; if (dett.DataScadenza != DateTime.MaxValue) dettaglio.DataScadenzaRata = dett.DataScadenza; if (dett.CodiceRata != null) dettaglio.Rata = rateSoggetti.FirstOrDefault(item => item.ID == dett.CodiceRata) ?? _daoFactory.GetRataSoggettoDao().GetById(dett.CodiceRata.Value, false); } listaSolleciti.Add(sollecito); _daoFactory.GetSollecitoDao().SaveOrUpdate(sollecito); } } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel calcolo del sollecito per soggetto - {0} - esercizio:{1} - soggetto:{2}", ex, Utility.GetMethodDescription(), idEsercizio, id); throw; } } // ================================================================================================================ // Rimuovo eventuali dettagli con importo a 0 // ================================================================================================================ foreach (var testataSollecitoDTO in solleciti) { var dettagliDaRimuovere = testataSollecitoDTO.Dettagli.Where(dettaglioSollecitoDTO => dettaglioSollecitoDTO.Importo == 0 && dettaglioSollecitoDTO.ImportoDaVersare == 0 && dettaglioSollecitoDTO.ImportoPagato == 0).ToList(); foreach (var dettaglioSollecitoDTO in dettagliDaRimuovere) testataSollecitoDTO.Dettagli.Remove(dettaglioSollecitoDTO); } // ================================================================================================================ // Creo i movimenti di addebito - una testata per ogni Esercizio (possibile solo se è stato richiesto lo STORICO) // ================================================================================================================ try { if (importoCompetenza > 0) { var sollecitiPerEsercizio = listaSolleciti.GroupBy(item => item.Esercizio); foreach (var sollecitiEsercizio in sollecitiPerEsercizio) { var esercizioAddebito = sollecitiEsercizio.Key; Conto contoAddebito = null; SottoConto sottoContoAddebito = null; if (idConto != null) { contoAddebito = _daoFactory.GetContoDao().Find(idConto.Value, false); if (idSottoConto != null) sottoContoAddebito = _daoFactory.GetSottoContoDao().GetById(idSottoConto.Value, false); } if (contoAddebito == null) { sottoContoAddebito = _daoFactory.GetSottoContoDao().GetAddebitoCompetenzeByEsercizio(esercizioAddebito.ID, esercizioAddebito.CondominioRiferimento.ID); if (sottoContoAddebito != null) contoAddebito = sottoContoAddebito.ContoRiferimento; } if (contoAddebito != null && esercizioAddebito != null) { var testata = _movimentiContabileService.SetMovimentiSollecito(esercizioAddebito, sollecitiEsercizio.ToList(), dataRegistrazioneContabile.GetValueOrDefault(), contoAddebito, sottoContoAddebito); // ------------------------------------------- // Genero il protocollo di archiviazione // ------------------------------------------- var progressivo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, testata.EsercizioRiferimento.DataApertura.GetValueOrDefault().Year, testata.EsercizioRiferimento.CondominioRiferimento); if (progressivo.Progressivo != null) { testata.NumeroProtocollo = progressivo.Progressivo.Value; testata.AnnoArchiviazioneOttica = testata.EsercizioRiferimento.DataApertura.GetValueOrDefault().Year; } else { _log.ErrorFormat("Errore imprevisto nella generazione del protocollo di archiviazione - {0} - esercizio:{1} - testata:{2} - message:{3}", Utility.GetMethodDescription(), esercizioAddebito.ID, testata.ID, progressivo.Message); } } } } } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel calcolo del sollecito per soggetto - CREAZIONE MOVIMENTI CONTABILI - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio); throw; } return solleciti; } catch (Exception ex) { _log.ErrorFormat("Errore inaspettato nel calcolo del sollecito per soggetto - CREAZIONE MOVIMENTI CONTABILI - {0} - esercizio:{1} - groupByPersone:{2} - dataRate:{3} - dataVersamenti:{4} - importoLimite:{5} - importoCompetenza:{6} - dataSollecito:{7} - stampaProprietario:{8} - idBanca:{9} - idModelloLettera:{10} - dataRegistrazioneContabile:{11} - idConto:{12} - idSottoConto:{13} - storico:{14} - esercizio:{15}", ex, Utility.GetMethodDescription(), idEsercizio.GetValueOrDefault(), groupByPersone, dataRate, dataVersamenti, importoLimite, importoCompetenza, dataSollecito, stampaProprietario, idBanca, idModelloLettera, dataRegistrazioneContabile, idConto, idSottoConto, storico, idEsercizio); throw; } }
internal static Mapping <T> GetEntityMapping <T>( DbContext context, Type queryClass, Dictionary <Type, PropertyInfo[]> allowedPropertyMapping ) { var allowedProperties = new HashSet <PropertyInfo>( allowedPropertyMapping.SelectMany(x => x.Value)); var inParam = Expression.Parameter(typeof(T), "x"); var inMappingPairs = new List <Tuple <MemberInfo, Expression> >(); var outParam = Expression.Parameter(queryClass, "x"); var outMappingPairs = new List <Tuple <MemberInfo, Expression> >(); var usedProperties = new Dictionary <string, Func <T, object> >(); var pkColumnName = EFHelper.GetKeyProperty(context, queryClass); if (pkColumnName == null) { throw new NotSupportedException($"{queryClass.Name} should have PK set"); } var columnNamesDict = EFHelper.GetColumnNames(context, queryClass); var members = typeof(T).GetProperties().Cast <MemberInfo>().Union(typeof(T).GetFields()); foreach (var member in members) { var memberType = member.MemberType == MemberTypes.Property ? ((PropertyInfo)member).PropertyType : ((FieldInfo)member).FieldType; var baseType = Nullable.GetUnderlyingType(memberType) ?? memberType; if (!allowedPropertyMapping.TryGetValue(baseType, out var allowedMappedProps)) { throw new NotSupportedException("Not supported property type"); } var mapProperty = allowedMappedProps.FirstOrDefault(x => allowedProperties.Contains(x)); if (mapProperty == null) { throw new NotSupportedException("Too complex object"); } Expression inExp = Expression.MakeMemberAccess(inParam, member); if (mapProperty.PropertyType != memberType) { inExp = Expression.Convert(inExp, mapProperty.PropertyType); } inMappingPairs.Add(new Tuple <MemberInfo, Expression>(mapProperty, inExp)); Expression outExp = Expression.MakeMemberAccess(outParam, mapProperty); if (mapProperty.PropertyType != memberType) { outExp = Expression.Convert(outExp, memberType); } outMappingPairs.Add(new Tuple <MemberInfo, Expression>(member, outExp)); allowedProperties.Remove(mapProperty); usedProperties.Add( columnNamesDict[mapProperty], (Func <T, object>)(Expression.Lambda( Expression.Convert(inExp, typeof(object)), inParam ).Compile())); } var inCtor = queryClass.GetConstructor(new Type[] { }); var inNew = Expression.New(inCtor); var inBind = Expression.MemberInit(inNew, inMappingPairs.Select(x => Expression.Bind(x.Item1, x.Item2))); // var inExpression = Expression.Lambda(inBind, inParam); var outCtor = typeof(T).GetConstructors( BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public); var emptyCtor = outCtor.FirstOrDefault(x => x.GetParameters().Length == 0); Expression outExpression; if (emptyCtor != null) { var outNew = Expression.New(emptyCtor); var outBind = Expression.MemberInit(outNew, outMappingPairs.Select(x => Expression.Bind(x.Item1, x.Item2))); outExpression = Expression.Lambda(outBind, outParam); } else { var outNew = Expression.New( outCtor.First(), outMappingPairs.Select(x => x.Item2).ToArray(), outMappingPairs.Select(x => x.Item1).ToArray()); outExpression = Expression.Lambda(outNew, outParam); } return(new Mapping <T>() { UserProperties = usedProperties, OutExpression = outExpression, KeyColumnName = pkColumnName }); }
/// <summary> /// Find all ranges of the specified strings. /// </summary> /// <param name="words">Must be a dictionary of strings (keys) to search for and /// whether these strings represent whole words (true or false value).</param> /// <returns></returns> private IEnumerable<int[]> FindWordRanges(Dictionary<string, bool> words) => words.SelectMany(word => FindWordRanges(word.Key, word.Value));
private bool _languageNamesExists(string languageName) { return(_languages.SelectMany(t => _languages).Any(languages => languages.Key == languageName)); }
public PivotedRows GroupAndTotal(TickCounter tickCounter, PivotedRows pivotedRows) { IDictionary<IList<Tuple<PropertyPath, PivotKey, object>>, List<GroupedRow>> allReportRows = new Dictionary<IList<Tuple<PropertyPath, PivotKey, object>>, List<GroupedRow>>(); var groupColumns = ViewInfo.DisplayColumns .Where(col => TotalOperation.GroupBy == col.ColumnSpec.TotalOperation) .Select(col => col.ColumnDescriptor) .ToArray(); var pivotOnColumns = ViewInfo.DisplayColumns .Where(col => TotalOperation.PivotKey == col.ColumnSpec.TotalOperation) .Select(col => col.ColumnDescriptor) .ToArray(); var allInnerPivotKeys = new HashSet<PivotKey>(); var allPivotKeys = new Dictionary<PivotKey, PivotKey>(); foreach (var rowItem in pivotedRows.RowItems) { allInnerPivotKeys.UnionWith(rowItem.PivotKeys); IList<Tuple<PropertyPath, PivotKey, object>> groupKey = new List<Tuple<PropertyPath, PivotKey, object>>(); foreach (var column in groupColumns) { var pivotColumn = GetPivotColumn(column); if (null == pivotColumn) { groupKey.Add(new Tuple<PropertyPath, PivotKey, object>(column.PropertyPath, null, column.GetPropertyValue(rowItem, null))); } else { foreach (var pivotKey in GetPivotKeys(pivotColumn.PropertyPath, new []{rowItem})) { if (!pivotKey.Contains(pivotColumn.PropertyPath)) { continue; } groupKey.Add(new Tuple<PropertyPath, PivotKey, object>(column.PropertyPath, pivotKey, column.GetPropertyValue(rowItem, pivotKey))); } } } groupKey = ImmutableList.ValueOf(groupKey); var pivotOnKeyValues = new List<KeyValuePair<PropertyPath, object>>(); foreach (var column in pivotOnColumns) { var pivotColumn = GetPivotColumn(column); if (null == pivotColumn) { pivotOnKeyValues.Add(new KeyValuePair<PropertyPath, object>(column.PropertyPath, column.GetPropertyValue(rowItem, null))); } else { Trace.TraceWarning("Unable to pivot on column {0} because it is already pivoted.", pivotColumn.PropertyPath); // Not L10N } } var pivotOnKey = PivotKey.GetPivotKey(allPivotKeys, pivotOnKeyValues); List<GroupedRow> rowGroups; if (!allReportRows.TryGetValue(groupKey, out rowGroups)) { rowGroups = new List<GroupedRow>(); allReportRows.Add(groupKey, rowGroups); } var rowGroup = rowGroups.FirstOrDefault(rg => !rg.ContainsKey(pivotOnKey)); if (null == rowGroup) { rowGroup = new GroupedRow(); rowGroups.Add(rowGroup); } rowGroup.AddInnerRow(pivotOnKey, rowItem); } var outerPivotKeys = allPivotKeys.Keys.Where(key=>key.Length == pivotOnColumns.Length).ToArray(); var pivotKeyComparer = PivotKey.GetComparer(ViewInfo.DataSchema); Array.Sort(outerPivotKeys, pivotKeyComparer); var innerPivotKeys = allInnerPivotKeys.ToArray(); Array.Sort(innerPivotKeys, pivotKeyComparer); var reportItemProperties = new List<PropertyDescriptor>(); var propertyNames = new HashSet<string>(); foreach (var displayColumn in ViewInfo.DisplayColumns) { if (displayColumn.ColumnSpec.Hidden) { continue; } var totalOperation = displayColumn.ColumnSpec.TotalOperation; if (TotalOperation.GroupBy == totalOperation) { var pivotColumn = GetPivotColumn(displayColumn.ColumnDescriptor); if (null == pivotColumn) { string propertyName = MakeUniqueName(propertyNames, displayColumn.PropertyPath); reportItemProperties.Add(new GroupedPropertyDescriptor(propertyName, displayColumn, null)); } else { foreach (var innerPivotKey in innerPivotKeys) { string propertyName = MakeUniqueName(propertyNames, displayColumn.PropertyPath); reportItemProperties.Add(new GroupedPropertyDescriptor(propertyName, displayColumn, innerPivotKey)); } } } } foreach (var outerPivotKey in outerPivotKeys) { foreach (var displayColumn in ViewInfo.DisplayColumns) { if (displayColumn.ColumnSpec.Hidden) { continue; } if (TotalOperation.PivotValue == displayColumn.ColumnSpec.TotalOperation || TotalOperation.PivotKey == displayColumn.ColumnSpec.TotalOperation) { var pivotColumn = GetPivotColumn(displayColumn.ColumnDescriptor); if (null == pivotColumn) { string propertyName = MakeUniqueName(propertyNames, displayColumn.PropertyPath); reportItemProperties.Add(new GroupedPropertyDescriptor(propertyName, outerPivotKey, displayColumn, null)); } else { foreach (var innerPivotKey in allInnerPivotKeys) { string propertyName = MakeUniqueName(propertyNames, displayColumn.PropertyPath); reportItemProperties.Add(new GroupedPropertyDescriptor(propertyName, outerPivotKey, displayColumn, innerPivotKey)); } } } } } return new PivotedRows(allReportRows.SelectMany(entry=>entry.Value.Select( reportRow=>new RowItem(reportRow))), new PropertyDescriptorCollection(reportItemProperties.ToArray())); }
private Dictionary <long, FinalBuffs>[] GetBoonsForPlayers(List <Player> playerList, Player player) { Dictionary <long, FinalBuffs>[] uptimesByPhase = new Dictionary <long, FinalBuffs> [_statistics.Phases.Count]; for (int phaseIndex = 0; phaseIndex < _statistics.Phases.Count; phaseIndex++) { PhaseData phase = _statistics.Phases[phaseIndex]; long fightDuration = phase.End - phase.Start; Dictionary <Player, BoonDistribution> boonDistributions = new Dictionary <Player, BoonDistribution>(); foreach (Player p in playerList) { boonDistributions[p] = p.GetBoonDistribution(_log, phaseIndex); } HashSet <Boon> boonsToTrack = new HashSet <Boon>(boonDistributions.SelectMany(x => x.Value).Select(x => Boon.BoonsByIds[x.Key])); Dictionary <long, FinalBuffs> final = new Dictionary <long, FinalBuffs>(); foreach (Boon boon in boonsToTrack) { long totalGeneration = 0; long totalOverstack = 0; long totalWasted = 0; long totalUnknownExtension = 0; long totalExtension = 0; long totalExtended = 0; bool hasGeneration = false; foreach (BoonDistribution boons in boonDistributions.Values) { if (boons.ContainsKey(boon.ID)) { hasGeneration = hasGeneration || boons.HasSrc(boon.ID, player.AgentItem); totalGeneration += boons.GetGeneration(boon.ID, player.AgentItem); totalOverstack += boons.GetOverstack(boon.ID, player.AgentItem); totalWasted += boons.GetWaste(boon.ID, player.AgentItem); totalUnknownExtension += boons.GetUnknownExtension(boon.ID, player.AgentItem); totalExtension += boons.GetExtension(boon.ID, player.AgentItem); totalExtended += boons.GetExtended(boon.ID, player.AgentItem); } } if (hasGeneration) { FinalBuffs uptime = new FinalBuffs(); final[boon.ID] = uptime; if (boon.Type == Boon.BoonType.Duration) { uptime.Generation = Math.Round(100.0 * totalGeneration / fightDuration / playerList.Count, 2); uptime.Overstack = Math.Round(100.0 * (totalOverstack + totalGeneration) / fightDuration / playerList.Count, 2); uptime.Wasted = Math.Round(100.0 * (totalWasted) / fightDuration / playerList.Count, 2); uptime.UnknownExtended = Math.Round(100.0 * (totalUnknownExtension) / fightDuration / playerList.Count, 2); uptime.ByExtension = Math.Round(100.0 * (totalExtension) / fightDuration / playerList.Count, 2); uptime.Extended = Math.Round(100.0 * (totalExtended) / fightDuration / playerList.Count, 2); } else if (boon.Type == Boon.BoonType.Intensity) { uptime.Generation = Math.Round((double)totalGeneration / fightDuration / playerList.Count, 2); uptime.Overstack = Math.Round((double)(totalOverstack + totalGeneration) / fightDuration / playerList.Count, 2); uptime.Wasted = Math.Round((double)(totalWasted) / fightDuration / playerList.Count, 2); uptime.UnknownExtended = Math.Round((double)(totalUnknownExtension) / fightDuration / playerList.Count, 2); uptime.ByExtension = Math.Round((double)(totalExtension) / fightDuration / playerList.Count, 2); uptime.Extended = Math.Round((double)(totalExtended) / fightDuration / playerList.Count, 2); } } } uptimesByPhase[phaseIndex] = final; } return(uptimesByPhase); }
static void Main(string[] args) { var assemblyDictionary = new Dictionary<int, Assembly>() { { 1, Assembly.GetAssembly(typeof(Certification.Chapter1.Objective1_1.Threads.Listing_1_1)) }, { 2 , Assembly.GetAssembly(typeof(Certification.Chapter2.Objective2_1.Listing_2_1)) }, { 3, Assembly.GetAssembly(typeof(Chapter3.Objective1.Listing_3_6)) } }; var typeDictionary = new Dictionary<int, IEnumerable<Type>>(); foreach (var kvp in assemblyDictionary) { typeDictionary.Add(kvp.Key, kvp.Value.GetTypes() .Where(type => type != typeof(IRunnable) && typeof(IRunnable).IsAssignableFrom(type))); } while (true) { Console.WriteLine("Enter the listing number:"); var input = Console.ReadLine(); bool isListing = Regex.IsMatch(input, listingRegExp); bool isChapter = Regex.IsMatch(input, chapterRegExp); if (isChapter) { IEnumerable<Type> listings; var chapterNumber = int.Parse(input); if (typeDictionary.TryGetValue(chapterNumber, out listings)) { Console.WriteLine("Available listing are:"); var listingNames = listings.Select(l => l.Name.Replace(typePrefix, string.Empty).Replace("_", ".")); foreach (var listing in listings.OrderBy(l => GetListingNumber(l))) { var displayName = listing.Name.Replace(typePrefix, string.Empty).Replace("_", "."); var listingAttribute = (ListingAttribute)Attribute.GetCustomAttribute(listing, typeof(ListingAttribute)); if (listingAttribute != null) { displayName += " - " + listingAttribute.Description; } Console.WriteLine(displayName); } } else { Console.WriteLine("Chapter " + input + " is unknown."); } } else if (isListing) { input = input.Replace('.', '_'); var type = typeDictionary.SelectMany(kvp => kvp.Value).FirstOrDefault(t => t.Name == typePrefix + input); if (type == null) { Console.WriteLine("Unknown listing {0}", typePrefix + input); } else { var runnable = (IRunnable)(type.GetConstructor(new Type[0]).Invoke(new object[0])); var listingAttribute = (ListingAttribute)Attribute.GetCustomAttribute(type, typeof(ListingAttribute)); if (listingAttribute != null) { Console.WriteLine("Running listing \"" + listingAttribute.Description + "\""); Console.WriteLine(); } runnable.Run(); Console.WriteLine("_______________________________________________________"); } } else if (input == "0" || input == String.Empty) { Console.WriteLine("Bye bye pov' type"); Thread.Sleep(500); return; } } }
public void PostTraceReconciliation(Dictionary <Guid, List <ISerializable> > orphanedSerializables) { Assert.AreEqual(orphanedSerializables.SelectMany(kvp => kvp.Value).Count(), ExpectedOrphanCount); }
public void NonSatisfiedImports() { var lockKey = new DatasetLockKey(); var datasetLock = new Mock<ITrackDatasetLocks>(); { datasetLock.Setup(d => d.LockForReading()) .Returns(lockKey) .Verifiable(); datasetLock.Setup(d => d.RemoveReadLock(It.IsAny<DatasetLockKey>())) .Callback<DatasetLockKey>(key => Assert.AreSame(lockKey, key)) .Verifiable(); } var groups = new Dictionary<GroupCompositionId, IEnumerable<GroupImportDefinition>> { { new GroupCompositionId(), new List<GroupImportDefinition> { GroupImportDefinition.CreateDefinition( "a", new GroupRegistrationId("a"), null, Enumerable.Empty<ImportRegistrationId>()), GroupImportDefinition.CreateDefinition( "b", new GroupRegistrationId("a"), null, Enumerable.Empty<ImportRegistrationId>()), } }, { new GroupCompositionId(), new List<GroupImportDefinition> { GroupImportDefinition.CreateDefinition( "c", new GroupRegistrationId("c"), null, Enumerable.Empty<ImportRegistrationId>()), GroupImportDefinition.CreateDefinition( "d", new GroupRegistrationId("c"), null, Enumerable.Empty<ImportRegistrationId>()), } }, }; var storage = new Mock<IStoreGroupsAndConnections>(); { storage.Setup(s => s.Groups()) .Returns(groups.Keys); storage.Setup(s => s.UnsatisfiedImports(It.IsAny<GroupCompositionId>())) .Returns<GroupCompositionId>(id => groups[id]); } var commands = new CompositionCommands(datasetLock.Object, storage.Object); var task = commands.NonSatisfiedImports(false); var results = task.Result; Assert.That( results, Is.EquivalentTo( groups.SelectMany(p => p.Value.Select(v => new Tuple<GroupCompositionId, GroupImportDefinition>(p.Key, v))))); datasetLock.Verify(d => d.LockForReading(), Times.Once()); datasetLock.Verify(d => d.RemoveReadLock(It.IsAny<DatasetLockKey>()), Times.Once()); }