private static int CompareArticlesDependency(
IPayrollArticle articleOne, IPayrollArticle[] relatedOne, SymbolName[] summaryOne,
IPayrollArticle articleTwo, IPayrollArticle[] relatedTwo, SymbolName[] summaryTwo)
{
if (articleOne.Category() != articleTwo.Category())
{
int compareResult = articleOne.Category().CompareTo(articleTwo.Category());
return(compareResult);
}
else if (RelatedArticlesForCode(relatedOne, articleTwo.ArticleCode()))
{
return(1);
}
else if (RelatedArticlesForCode(relatedTwo, articleOne.ArticleCode()))
{
return(-1);
}
else if (SummaryArticlesForCode(summaryOne, articleTwo.ArticleCode()))
{
return(-1);
}
else if (SummaryArticlesForCode(summaryTwo, articleOne.ArticleCode()))
{
return(1);
}
else
{
int compareResult = articleOne.ArticleCode().CompareTo(articleTwo.ArticleCode());
return(compareResult);
}
}
private static IPayrollArticle[] CollectFromPending(IDictionary <uint, IPayrollArticle[]> relatedDict,
IPayrollArticle article, SymbolName[] articlePath, IDictionary <uint, IPayrollArticle[]> pendingDict, IProcessConfigLogger logger)
{
uint articleCode = article.ArticleCode();
bool skipExecToRelated = relatedDict.ContainsKey(articleCode);
if (skipExecToRelated)
{
return(null);
}
VerifyCircularDependency(article, articlePath, articleCode);
var initialArticles = new IPayrollArticle[] { article };
var callingArticles = articlePath.Concat(new SymbolName[] { article.ArticleSymbol() }).ToArray();
var pendingArticles = FindArticlesInDictionary(pendingDict, article);
var collectArticles = pendingArticles.Aggregate(initialArticles,
(agr, articleSource) => agr.Concat(ResolveArticleDependency(relatedDict, articleSource, callingArticles, pendingDict, logger)).ToArray());
var relatedArticles = collectArticles.Distinct().OrderBy(x => x.ArticleSymbol()).ToArray();
return(relatedArticles);
}
public void LogPendingArticles(IPayrollArticle article, SymbolName[] callings, IPayrollArticle[] articles, string testName)
{
OpenLogStream(testName);
using (StreamWriter logWriter = new StreamWriter(LogFileStream))
{
string lineDefinition = "\n--- begin ---";
lineDefinition += ArticleListCodesLogger.LogArticleInfo(article);
lineDefinition += "\n--- CALLING PATH ---";
lineDefinition += ArticleListCodesLogger.LogArrayOfSymbols(callings);
lineDefinition += "\n--- CALCULATED ---";
lineDefinition += ArticleListCodesLogger.LogArrayOfArticles(article.ArticleCode(), articles);
if (lineDefinition.Length > 0)
{
logWriter.WriteLine(lineDefinition);
}
logWriter.WriteLine("--- end ---");
}
}
public uint ArticleCode()
{
if (__article == null)
{
return((uint)ArticleSymbolCode.ARTICLE_UNKNOWN);
}
return(__article.ArticleCode());
}
public void Should_Return_UnknownArticle_From_Models()
{
SymbolName testSpecName = ArticleSymbolName.REF_UNKNOWN;
IPayrollArticle testArticle = testConfig.FindArticle(testSpecName.Code);
Type testTypeOfArticle = testArticle.GetType();
Assert.AreSame(typeof(UnknownArticle), testTypeOfArticle);
Assert.AreEqual(testArticle.ArticleCode(), testSpecName.Code);
}
private static IPayrollArticle[] FindArticlesInDictionary(IDictionary <uint, IPayrollArticle[]> articlesDict, IPayrollArticle article)
{
IPayrollArticle[] articleList = null;
uint articleCode = article.ArticleCode();
bool existsInDictionary = articlesDict.TryGetValue(articleCode, out articleList);
if (existsInDictionary)
{
return(articleList);
}
return(new IPayrollArticle[0]);
}
private static IPayrollArticle[] FindArticleListInDictionary(IDictionary <uint, IPayrollArticle[]> articlesDict, IPayrollArticle article)
{
uint articleCode = article.ArticleCode();
IPayrollArticle[] articleList = null;
bool existsInDictionary = articlesDict.TryGetValue(articleCode, out articleList);
if (existsInDictionary)
{
return(articleList);
}
return(EMPTY_ARTICLE_LIST);
}
private static IPayrollArticle[] CollectFromRelated(IDictionary <uint, IPayrollArticle[]> relatedDict,
IPayrollArticle article, IDictionary <uint, IPayrollArticle[]> pendingDict)
{
uint articleCode = article.ArticleCode();
bool skipExecToPending = !relatedDict.ContainsKey(articleCode);
if (skipExecToPending)
{
return(null);
}
var initialArticles = new IPayrollArticle[] { article };
var relatedArticles = FindArticlesInDictionary(relatedDict, article);
return(initialArticles.Concat(relatedArticles).ToArray());
}
public void LogRelatedArticles(IPayrollArticle article, IPayrollArticle[] articles, string testName)
{
OpenLogStream(testName);
using (StreamWriter logWriter = new StreamWriter(LogFileStream))
{
string lineDefinition = "\n--- begin ---";
lineDefinition += ArticleListCodesLogger.LogArticleInfo(article);
lineDefinition += "\n--- EXISTS IN RELATED ---";
lineDefinition += ArticleListCodesLogger.LogArrayOfArticles(article.ArticleCode(), articles);
if (lineDefinition.Length > 0)
{
logWriter.WriteLine(lineDefinition);
}
logWriter.WriteLine("--- end ---");
}
}
public static string LogArticleInfo(IPayrollArticle article)
{
string lineDefinition = string.Format("\n\t{0} - {1} - {2}", article.ArticleName(), article.ConceptName(), article.ArticleCode());
return(lineDefinition);
}
public static string LogResultInfo(IBookResult result)
{
IPayrollArticle article = result.Article();
IBookIndex element = result.Element();
string lineDefinition = string.Format("\n--- {0} - {1} - {2} - {3}",
article.ArticleName(), article.ConceptName(), article.ArticleCode(), element.ToString());
foreach (var targetValue in result.TargetValues())
{
lineDefinition += string.Format("\n\t--> {0} - {1}", targetValue, LogValueInfo(targetValue, result.Values()));
}
foreach (var resultValue in result.ResultValues())
{
lineDefinition += string.Format("\n\t<-- {0} - {1}", resultValue, LogValueInfo(resultValue, result.Values()));
}
return(lineDefinition);
}
public static string LogArticleInfo(IBookTarget target)
{
IPayrollArticle article = target.Article();
IBookIndex element = target.Element();
string lineDefinition = string.Format("\n--- {0} - {1} - {2} - {3}",
article.ArticleName(), article.ConceptName(), article.ArticleCode(), element.ToString());
return(lineDefinition);
}