/// <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 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);
}
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}));
}
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());
}
}
/// <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_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 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);
}
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 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 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 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 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 };
}
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 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()
};
}
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 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()));
}
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));
}
}
/// <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 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 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();
}
}
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());
}
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);
}
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;
}
}
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;
}
