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);
}
}
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 static void LogListArticlesUnderArticle(IProcessConfigLogger logger, IPayrollArticle article, IPayrollArticle[] articles, string testName)
{
if (logger != null)
{
logger.LogListArticlesUnderArticle(article, articles, testName);
}
}
public static void LogRelatedArticles(IProcessConfigLogger logger, IPayrollArticle article, IPayrollArticle[] articles, string testName)
{
if (logger != null)
{
logger.LogRelatedArticles(article, articles, testName);
}
}
public static void LogPendingArticles(IProcessConfigLogger logger, IPayrollArticle article, SymbolName[] callings, IPayrollArticle[] articles, string testName)
{
if (logger != null)
{
logger.LogPendingArticles(article, callings, articles, testName);
}
}
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 static string LogArticleInfo(IPayrollArticle article)
{
string calcDefinition = Enum.ToObject(typeof(ProcessCategory), article.Category()).ToString();
string lineDefinition = string.Format("{0}\t{1}\n", article.ArticleName(), calcDefinition);
return(lineDefinition);
}
public static IBookResult[] BuildListWithEmptyResult(IBookIndex element, IPayrollArticle article)
{
IBookResult result = BookResultBuilder.CreateEmptyResult(element, article);
IBookResult[] resultList = BuildListWithResult(result);
return(resultList);
}
public static string LogRelatedArticlesInfo(IPayrollArticle article)
{
var articles = article.RelatedArticles();
string lineDefinition = ArticlesRelatedListLogger.LogArrayOfArticles(articles);
return(lineDefinition);
}
public virtual IBookResult[] CallEvaluate(IProcessConfig config, IEngineProfile engine,
IPayrollArticle article, IBookIndex element, ITargetValues values, IResultStream results)
{
if (__evaluate != null)
{
return(__evaluate(this, config, engine, article, element, values, results));
}
return(GeneralModule.EMPTY_RESULT_LIST);
}
private static void VerifyCircularDependency(IPayrollArticle article, SymbolName[] articlePath, uint articleCode)
{
bool articlesCircle = (articlePath.Count(x => x.Code == articleCode) > 0);
if (articlesCircle)
{
throw new EngineProcessCircleException("Circular article reference", articlePath, article.ArticleSymbol());
}
}
public static string LogArticleInfo(IPayrollArticle article)
{
string relatedDescrip = article.RelatedArticles().Length.ToString();
string lineDefinition = string.Format("{0} - {1}\n", article.ConceptName(), relatedDescrip);
lineDefinition += LogRelatedArticlesInfo(article);
return(lineDefinition);
}
public BookTarget(IBookIndex bookElement, IPayrollArticle bookArticle, IPayrollConcept bookConcept, ITargetValues bookValues)
{
__element = bookElement;
__article = bookArticle;
__concept = bookConcept;
__values = bookValues;
}
public IPayrollArticle ConfigureArticle(SymbolName article, SymbolName concept, ProcessCategory category,
SymbolName[] pendingNames, SymbolName[] summaryNames,
bool taxingIncome, bool healthIncome, bool socialIncome, bool grossSummary, bool nettoSummary, bool nettoDeducts)
{
IPayrollArticle articleInstance = GeneralPayrollArticle.CreateArticle(
article, concept, category, pendingNames, summaryNames,
taxingIncome, healthIncome, socialIncome, grossSummary, nettoSummary, nettoDeducts);
return(ConfigureModel(articleInstance, article.Code));
}
public static IPayrollArticle[] BuildArticleStream(IDictionary <IBookIndex, IBookTarget> targets)
{
var initialStream = new IPayrollArticle[0];
var articleStream = targets.Aggregate(initialStream,
(agr, targetPair) => ConcatArticles(agr, targetPair.Value).ToArray());
var articleUnique = articleStream.Distinct().ToArray();
return(articleUnique);
}
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);
}
public void Should_Return_UnknownArticle_As_TypeOf()
{
SymbolName testSpecName = ConfigSetCzArticleName.REF_UNKNOWN;
Assembly configAssembly = typeof(ProcessConfigSetCzModule).Assembly;
IPayrollArticle testArticle = PayrollArticleFactory.ArticleFor(configAssembly, testSpecName.Name);
Type testTypeOfArticle = testArticle.GetType();
Assert.AreSame(typeof(UnknownArticle), testTypeOfArticle);
}
public static string LogArticleListInfo(IPayrollArticle article, IPayrollArticle[] articles)
{
string lineDefinition = LogHeaderInfo(article, articles);
//lineDefinition += "----------------------------";
lineDefinition += LogBodyOfArticles(articles);
//lineDefinition += "----------------------------";
return(lineDefinition);
}
public BookResult(IBookIndex element, IPayrollArticle article, IResultValues values, string[] targetValues, string[] resultValues)
{
__element = element;
__article = article;
__values = values;
__targetValues = targetValues;
__resultValues = resultValues;
}
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);
}
static public IBookTarget BuildTargetFromElement(IBookIndex element, ITargetValues values, IProcessConfig config)
{
uint articleCode = element.Code();
IPayrollArticle targetArticle = config.FindArticle(articleCode);
IPayrollConcept targetConcept = config.FindConcept(targetArticle.ConceptCode());
IBookTarget target = TargetFactory.BuildTargetWithValues(element, targetArticle, targetConcept, values);
return(target);
}
public static string LogArticleValuesNames(IPayrollArticle article)
{
string articleName = PayrollArticleFactory.ClassNameFor(article.ArticleName());
string lineDefinition = string.Format("\npublic static ITargetValues Create{0}Values()", articleName);
lineDefinition += " {\n";
lineDefinition += "\treturn new TargetValues (dateFrom, dateEnds, timeWeekly, timeWorked, timeAbsent, amountMonthly,\n\t\t\t\tcodeInterests, codeResidency, codeMandatory, codeStatement, codeHandicaps, codeCardinals);\n";
lineDefinition += "}\n";
return(lineDefinition);
}
public static string LogConceptInfo(IPayrollConcept concept, IPayrollArticle article)
{
string calcDefinition = Enum.ToObject(typeof(ProcessCategory), article.Category()).ToString();
string lineDefinition = string.Format("{0}\t{1}\t{2}\t", article.ArticleName(), concept.ConceptName(), calcDefinition);
lineDefinition += LogPendingArticlesInfo(article);
lineDefinition += LogSummaryArticlesInfo(article);
lineDefinition += LogSpecValuesInfo(concept);
return(lineDefinition);
}
public static string LogArticleEvalNames(IPayrollArticle article)
{
string articleName = PayrollArticleFactory.ClassNameFor(article.ArticleName());
string lineDefinition = string.Format("\npublic static GeneralModule.EvaluateDelegate {0}Evaluation = (concept, config, engine, article, element, targets, results) =>", articleName);
lineDefinition += " {\n";
lineDefinition += "\treturn BookResultBase.EMPTY_RESULT_LIST;\n";
lineDefinition += "};\n";
return(lineDefinition);
}
public void LogListArticlesUnderArticle(IPayrollArticle article, IPayrollArticle[] articles, string testName)
{
OpenLogStream(testName);
using (StreamWriter logWriter = new StreamWriter(LogFileStream))
{
//logWriter.WriteLine ("\n--- begin ---");
string lineDefinition = ArticlesRelatedListLogger.LogArticleListInfo(article, articles);
logWriter.WriteLine(lineDefinition);
//logWriter.WriteLine ("--- end ---");
}
}
public static int CompareArticles(IPayrollArticle entryOne, IPayrollArticle entryTwo)
{
IPayrollArticle articleOne = entryOne;
IPayrollArticle[] relatedOne = entryOne.RelatedArticles();
SymbolName[] summaryOne = articleOne.SummaryArticleNames();
IPayrollArticle articleTwo = entryTwo;
IPayrollArticle[] relatedTwo = entryTwo.RelatedArticles();
SymbolName[] summaryTwo = articleTwo.SummaryArticleNames();
return(CompareArticlesDependency(articleOne, relatedOne, summaryOne, articleTwo, relatedTwo, summaryTwo));
}
public static string LogHeaderInfo(IPayrollArticle article, IPayrollArticle[] articles)
{
string lineCountInfo = "";
if (articles == null)
{
lineCountInfo = "empty";
}
else
{
lineCountInfo = string.Format("{0}", articles.Length);
}
string lineDefinition = string.Format("count - {0} - {1} - {2} - {3}", lineCountInfo, article.ArticleName(), article.ConceptName(), article.ConceptCode());
return(lineDefinition);
}
public static int CompareDependency(Tuple <IPayrollArticle, IPayrollArticle[]> entryOne, Tuple <IPayrollArticle, IPayrollArticle[]> entryTwo)
{
IPayrollArticle articleOne = entryOne.Item1;
IPayrollArticle[] relatedOne = entryOne.Item2;
SymbolName[] summaryOne = articleOne.SummaryArticleNames();
IPayrollArticle articleTwo = entryTwo.Item1;
IPayrollArticle[] relatedTwo = entryTwo.Item2;
SymbolName[] summaryTwo = articleTwo.SummaryArticleNames();
return(CompareArticlesDependency(articleOne, relatedOne, summaryOne, articleTwo, relatedTwo, summaryTwo));
}
public static string LogSummaryArticlesInfo(IPayrollArticle parentArticle)
{
string lineDefinition = "";
var articles = parentArticle.SummaryArticleNames();
int articlesCount = articles.Length;
foreach (var article in articles)
{
lineDefinition = string.Format("{0}\t", article.Name);
}
for (int emptyColumn = articlesCount; emptyColumn < 1; emptyColumn++)
{
lineDefinition = string.Format("\t");
}
return(lineDefinition);
}
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());
}
