public void SaveProcessTest()
{
IProcessConfig config = null;
ConfigManager.Create("IE", out config);
ConfigManager.Save("IE", config);
}
public IResultStream EvaluateToResultStream(IProcessConfig config, IEngineProfile engine)
{
var targets = __targets;
var results = ResultsStreamBuilder.EvaluateTargetsToResults(targets, config, engine);
return(results);
}
/// <summary>
/// Load an existing windows process configuration from disk.
/// </summary>
/// <param name="name">display name for process</param>
/// <param name="config">windows process configuration</param>
public static void Load(string name, out IProcessConfig config)
{
config = null;
using (FileStream stream = ReadStream(name))
{
config = (IProcessConfig)ProcessFactory.Create(stream);
}
}
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 IResultStream EvaluateTarget(
IResultStream resultStream, IBookTarget target, IProcessConfig config, IEngineProfile engine)
{
var targetResults = target.Evaluate(config, engine, resultStream);
var results = resultStream.AggregateResultList(targetResults);
return(results);
}
private ProcessServiceModule(ITargetStream targets, IProcessConfig configModule, IEngineProfile engineModule, IProcessServiceLogger logger)
{
Targets = targets;
ConfigModule = configModule;
EngineModule = engineModule;
Logger = logger;
}
public void TestSetup()
{
IProcessConfigLogger logger = new TestConfigLogger("TestArticleDependencySort");
testConfig = ProcessConfigSetCzModule.CreateModule(logger);
testConfig.InitModule();
logger.CloseLogStream();
}
public void TestSetup()
{
IProcessConfigLogger logger = new TestEmptyLogger("TestConceptCollection");
testConfig = ProcessConfigSetCzModule.CreateModule(logger);
testConfig.InitModule();
logger.CloseLogStream();
}
public void TestSetup()
{
serviceLog = new TestTargetsLogger("TestTargetsCollection");
testConfig = ProcessConfigSetCzModule.CreateModule(null);
testEngine = EngineServiceModule.CreateModule();
testConfig.InitModule();
}
private static IDictionary <IBookIndex, IBookTarget> BuildArticleTarget(
IDictionary <IBookIndex, IBookTarget> initialStream, IBookParty addParty, IPayrollArticle article,
ITargetValues addValues, IProcessConfig configModule)
{
var results = TargetsTupleComposer.AddTargetBySymbol(initialStream,
addParty, article.ArticleSymbol(), addValues, configModule);
var targets = results.Item2;
return(targets);
}
public static Tuple <IBookIndex, IDictionary <IBookIndex, IBookTarget> > AddTargetBySymbol(
IDictionary <IBookIndex, IBookTarget> targets,
IBookParty party, SymbolName articleName, ITargetValues values, IProcessConfig config)
{
IBookIndex newIndex = TargetElementBuilder.BuildIndexWithFirst(targets.Keys, party, articleName.Code);
KeyValuePair <IBookIndex, IBookTarget> pairToMerge = TargetPairComposer
.ComposeTarget(party, articleName, newIndex, values, config);
var targetIndex = pairToMerge.Key;
var targetValue = pairToMerge.Value;
var bookTargets = TargetsDictComposer.MergeDictWithTargetPair(targets, targetIndex, targetValue);
return(Tuple.Create <IBookIndex, IDictionary <IBookIndex, IBookTarget> >(targetIndex, bookTargets));
}
public ITargetStream CreateEvaluationStream(IProcessConfig configModule)
{
IBookParty[] contracts = CollectPartiesForContracts();
IBookParty[] positions = CollectPartiesForPositions();
var targetsInit = TargetStreamBuilder.BuildStreamCopy(__targets);
var articleList = TargetStreamBuilder.BuildArticleStream(__targets);
var targetsDict = articleList.Aggregate(targetsInit,
(agr, article) => TargetStreamBuilder.BuildEvaluationStream(agr, contracts, positions, article, configModule));
var targetsEval = targetsDict.OrderBy(x => x.Value.Article()).
ToDictionary(key => key.Key, val => val.Value);
var lastParty = BookParty.GetEmpty();
var lastIndex = BookIndex.GetEmpty();
return(new TargetStream(targetsEval, lastParty, lastIndex));
}
/// <summary>
/// Save the windows process configuration for the given process.
/// </summary>
/// <param name="name">display name for process</param>
/// <param name="config">windows process configuration</param>
public static void Save(string name, IProcessConfig config)
{
Save(name, (object)config);
}
public static IProcessService CreateModule(ITargetStream targets, IProcessConfig configModule, IEngineProfile engineModule, IProcessServiceLogger logger)
{
IProcessService module = new ProcessServiceModule(targets, configModule, engineModule, logger);
return(module);
}
/// <summary>
/// Create a new windows process configuration filled with default values.
/// </summary>
/// <param name="name">display name for process</param>
/// <param name="config">windows process configuration</param>
public static void Create(string name, out IProcessConfig config)
{
config = (IProcessConfig)ProcessFactory.Create(name);
}
public IBookResult[] Evaluate(IProcessConfig config, IEngineProfile engine, IResultStream results)
{
return(__concept.CallEvaluate(config, engine, __article, __element, __values, results));
}
static public KeyValuePair <IBookIndex, IBookTarget> ComposeTarget(IBookParty party,
SymbolName articleName, IBookIndex element, ITargetValues values, IProcessConfig config)
{
IBookTarget target = BuildTargetFromElement(element, values, config);
return(new KeyValuePair <IBookIndex, IBookTarget>(element, target));
}
public static IResultStream EvaluateTargetsToResults(IDictionary <IBookIndex, IBookTarget> targets, IProcessConfig config, IEngineProfile engine)
{
IResultStream emptyResults = ResultStream.CreateEmptyStream();
var results = targets.Aggregate(emptyResults,
(agr, target) => EvaluateTarget(agr, target.Value, config, engine));
return(results);
}
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 void LoadProcessTest()
{
IProcessConfig config = null;
ConfigManager.Load("IE", out config);
}
public ITargetStream AddTargetIntoSubLevel(SymbolName article, ITargetValues values, IProcessConfig config)
{
uint articleCode = article.Code;
IPayrollArticle targetArticle = config.FindArticle(articleCode);
uint conceptCode = targetArticle.ConceptCode();
IPayrollConcept targetConcept = config.FindConcept(conceptCode);
IBookParty addParty = targetConcept.GetTargetParty(LastParty());
var retTuple = TargetsTupleComposer.AddTargetBySymbol(Targets(),
addParty, article, values, config);
var nextFacts = retTuple.Item2;
var nextIndex = retTuple.Item1;
var nextParty = targetConcept.GetNextTargetParty(nextIndex);
return(new TargetStream(nextFacts, nextParty, nextIndex));
}
public ITargetStream AddNewPositionsTarget(SymbolName article, ITargetValues values, IProcessConfig config)
{
var addParty = LastParty().GetNonPositionParty();
var retTuple = TargetsTupleComposer.AddTargetBySymbol(Targets(),
addParty, article, values, config);
var nextFacts = retTuple.Item2;
var nextIndex = retTuple.Item1;
var nextParty = nextIndex.GetNewPositionParty(nextIndex.Code(), nextIndex.CodeOrder());
return(new TargetStream(nextFacts, nextParty, nextIndex));
}
public static IDictionary <IBookIndex, IBookTarget> BuildEvaluationStream(IDictionary <IBookIndex, IBookTarget> initialStream,
IBookParty[] contracts, IBookParty[] positions, IPayrollArticle article, IProcessConfig configModule)
{
ITargetValues emptyValues = null;
IPayrollConcept concept = configModule.FindConcept(article.ConceptCode());
IBookParty[] parties = concept.GetTargetParties(BookParty.GetEmpty(), contracts, positions);
var targets = parties.Aggregate(initialStream,
(agr, party) => BuildArticleTarget(initialStream, party, article, emptyValues, configModule));
return(targets);
}
public static ITargetStream BuildCalculationStream(ITargetStream targets, IBookParty[] contractParties, IBookParty[] positionParties, IProcessConfig configModule)
{
ITargetStream targetsInit = targets.CreateStreamCopy();
IPayrollArticle[] relatedList = targetsInit.BookTargetToEvaluate();
ITargetStream processCalc = relatedList.Aggregate(targetsInit,
(agr, article) => agr.MergeRealtedArticle(contractParties, positionParties, article, configModule));
return(processCalc);
}
public ITargetStream AddTargetIntoSumLevel(SymbolName article, ITargetValues values, IProcessConfig config)
{
var addParty = LastParty().GetNonContractParty();
var retTuple = TargetsTupleComposer.AddTargetBySymbol(Targets(),
addParty, article, values, config);
var nextFacts = retTuple.Item2;
var nextIndex = retTuple.Item1;
var nextParty = nextIndex.GetParty();
return(new TargetStream(nextFacts, nextParty, nextIndex));
}
public override IBookResult[] CallEvaluate(IProcessConfig config, IEngineProfile engine,
IPayrollArticle article, IBookIndex element, ITargetValues values, IResultStream results)
{
return(GeneralModule.EMPTY_RESULT_LIST);
}
