public void SetOptions()
{
this.AnalyzerType = GetAnalyzerType();
this.HCCalculatorParams.AnalyzerParms.AnalyzerType = this.AnalyzerType.ToString();
if (this.HCCalculatorParams.AnalyzerParms.AnalyzerType == string.Empty ||
this.HCCalculatorParams.AnalyzerParms.AnalyzerType == Constants.NONE)
{
this.HCCalculatorParams.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_CHOOSEONE");
}
this.HCCalculatorParams.AnalyzerParms.AnalyzerGeneralType
= GetBaseAnalyzerType(this.AnalyzerType);
this.HCCalculatorParams.AnalyzerParms.SubFolderType
= AnalyzerHelper.GetSubFolderType(this.HCCalculatorParams.LinkedViewElement);
this.HCCalculatorParams.AnalyzerParms.ComparisonType
= AnalyzerHelper.GetComparisonType(this.HCCalculatorParams.LinkedViewElement);
this.HCCalculatorParams.AnalyzerParms.AggregationType
= AnalyzerHelper.GetAggregationType(this.HCCalculatorParams.LinkedViewElement);
this.HCCalculatorParams.AnalyzerParms.FilesToAnalyzeExtensionType
= CalculatorHelpers.GetAttribute(this.HCCalculatorParams.LinkedViewElement,
Calculator1.cFilesToAnalyzeExtensionType);
this.HCCalculatorParams.CalculatorType
= this.HCCalculatorParams.AnalyzerParms.FilesToAnalyzeExtensionType;
if (this.AnalyzerType != ANALYZER_TYPES.resources01)
{
//resources01 uses the calculator pattern, which does not change startingdoctocalc
this.HCCalculatorParams.StartingDocToCalcNodeName
= GetNodeNameFromFileExtensionType(this.HCCalculatorParams.AnalyzerParms.FilesToAnalyzeExtensionType);
}
this.HCCalculatorParams.SubApplicationType
= CalculatorHelpers.GetSubAppTypeFromNodeName2(
this.HCCalculatorParams.StartingDocToCalcNodeName);
}
public bool RunHCCalculations(CalculatorParameters calcParameters,
HealthBenefit1Calculator hcBenefit1)
{
bool bHasCalculations = false;
if (hcBenefit1 != null)
{
FixSelections(hcBenefit1);
//calculate the adjusted benefit
hcBenefit1.AdjustedBenefit = hcBenefit1.OutputCost * (hcBenefit1.BenefitAdjustment / 100);
//set the base input properties
//remember not to set amounts or the calcs have to be rerun in npv calcors
hcBenefit1.Price = hcBenefit1.AdjustedBenefit;
hcBenefit1.Unit = (hcBenefit1.Unit != string.Empty && hcBenefit1.Unit != Constants.NONE)
? hcBenefit1.Unit : Constants.EACH;
//set the bcrating (equally weighted)
SetAverageBenefitRating(hcBenefit1);
bHasCalculations = true;
}
else
{
calcParameters.ErrorMessage = Errors.MakeStandardErrorMsg("CALCULATORS_WRONG_ONE");
}
return(bHasCalculations);
}
private bool RunOperationComponentStatistic(XElement currentElement)
{
bool bHasStatistics = false;
if (this.AnalyzerType
== ARSAnalyzerHelper.ANALYZER_TYPES.statistics01)
{
StatisticalAnalyzer1 statsAnalyzer1
= new StatisticalAnalyzer1(this.GCCalculatorParams);
bHasStatistics = statsAnalyzer1.SetStatisticalCalculation(
currentElement);
statsAnalyzer1 = null;
}
else if (ARSAnalyzerHelper.IsEffectivenessAnalysis(
this.AnalyzerType))
{
if (this.ceAnalyzer == null)
{
this.ceAnalyzer
= new CostEffectivenessAnalyzer1(this.GCCalculatorParams);
}
bHasStatistics = SetEffectivenessStatistic(currentElement);
}
else
{
this.GCCalculatorParams.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_NOANALYZER");
}
return(bHasStatistics);
}
public ANALYZER_TYPES GetAnalyzerType(string analyzerType)
{
ANALYZER_TYPES eAnalyzerType = ANALYZER_TYPES.none;
if (analyzerType == ANALYZER_TYPES.metotal1.ToString())
{
eAnalyzerType = ANALYZER_TYPES.metotal1;
}
else if (analyzerType == ANALYZER_TYPES.mechangeyr.ToString())
{
eAnalyzerType = ANALYZER_TYPES.mechangeyr;
}
else if (analyzerType == ANALYZER_TYPES.mechangeid.ToString())
{
eAnalyzerType = ANALYZER_TYPES.mechangeid;
}
else if (analyzerType == ANALYZER_TYPES.mechangealt.ToString())
{
eAnalyzerType = ANALYZER_TYPES.mechangealt;
}
else if (analyzerType == ANALYZER_TYPES.meprogress1.ToString())
{
eAnalyzerType = ANALYZER_TYPES.meprogress1;
}
else if (analyzerType == ANALYZER_TYPES.mestat1.ToString())
{
eAnalyzerType = ANALYZER_TYPES.mestat1;
}
if (eAnalyzerType == ANALYZER_TYPES.none)
{
this.ME2CalculatorParams.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_CHOOSEONE");
}
return(eAnalyzerType);
}
public void SetOptions()
{
this.AnalyzerType = GetAnalyzerType();
this.ME2CalculatorParams.AnalyzerParms.AnalyzerType = this.AnalyzerType.ToString();
if (this.ME2CalculatorParams.AnalyzerParms.AnalyzerType == string.Empty ||
this.ME2CalculatorParams.AnalyzerParms.AnalyzerType == Constants.NONE)
{
this.ME2CalculatorParams.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_CHOOSEONE");
}
this.ME2CalculatorParams.AnalyzerParms.AnalyzerGeneralType
= GetBaseAnalyzerType(this.AnalyzerType);
this.ME2CalculatorParams.AnalyzerParms.SubFolderType
= AnalyzerHelper.GetSubFolderType(this.ME2CalculatorParams.LinkedViewElement);
this.ME2CalculatorParams.AnalyzerParms.ComparisonType
= AnalyzerHelper.GetComparisonType(this.ME2CalculatorParams.LinkedViewElement);
this.ME2CalculatorParams.AnalyzerParms.AggregationType
= AnalyzerHelper.GetAggregationType(this.ME2CalculatorParams.LinkedViewElement);
//new in v1.4.5 (user can choose whether or not to display full calcs)
this.ME2CalculatorParams.NeedsFullView
= AnalyzerHelper.GetDisplayFullViewOption(this.ME2CalculatorParams.LinkedViewElement);
this.ME2CalculatorParams.AnalyzerParms.FilesToAnalyzeExtensionType
= CalculatorHelpers.GetAttribute(this.ME2CalculatorParams.LinkedViewElement,
Calculator1.cFilesToAnalyzeExtensionType);
this.ME2CalculatorParams.StartingDocToCalcNodeName
= GetNodeNameFromFileExtensionType(this.ME2CalculatorParams.AnalyzerParms.FilesToAnalyzeExtensionType);
this.ME2CalculatorParams.SubApplicationType
= CalculatorHelpers.GetSubAppTypeFromNodeName2(
this.ME2CalculatorParams.StartingDocToCalcNodeName);
}
public async Task <bool> DoStepAsync(ContentURI docToCalcURI, ContentURI calcDocURI,
string extensionTypeName, IList <string> urisToAnalyze, IDictionary <string, string> updates,
CancellationToken cancellationToken)
{
bool bIsStepDone = false;
try
{
//extensiontypename (a parameter stored in db) determines
//extension to run
DoStepsHostView hostview = GetDoStepsView(calcDocURI,
extensionTypeName);
if (hostview != null)
{
//these extensions define their own number of steps internally
string sStepNumber = DataHelpers.AddInHelper.GetStepNumber(docToCalcURI);
//use the view to carry out the current step
bIsStepDone = await RunStepAsync(docToCalcURI, calcDocURI, sStepNumber,
hostview, urisToAnalyze, updates, cancellationToken);
}
else
{
docToCalcURI.ErrorMessage = Errors.MakeStandardErrorMsg("CALCULATORS_MISSING_HOST");
}
}
catch (CompositionException x)
{
docToCalcURI.ErrorMessage = x.ToString();
}
return(bIsStepDone);
}
public async Task <bool> RunAnalysis(IList <string> urisToAnalyze)
{
bool bHasAnalysis = false;
//set the files needing analysis
await CalculatorHelpers.SetFileOrFoldersToAnalyze(this.ARSCalculatorParams.AnalyzerParms.FilesToAnalyzeExtensionType,
this.ARSCalculatorParams, urisToAnalyze);
//run the analysis
if (this.ARSCalculatorParams.AnalyzerParms.FileOrFolderPaths != null)
{
if (this.ARSCalculatorParams.AnalyzerParms.FileOrFolderPaths.Count > 0)
{
//build the base file needed by the regular analysis
this.ARSCalculatorParams.AnalyzerParms.ObservationsPath
= await CalculatorHelpers.GetFullCalculatorResultsPath(this.ARSCalculatorParams);
bHasAnalysis = await CalculatorHelpers.AddFilesToBaseDocument(this.ARSCalculatorParams);
if (bHasAnalysis)
{
//run the regular analysis
bHasAnalysis = await RunCalculations();
if (bHasAnalysis)
{
//v170 set devpack params
CalculatorHelpers.UpdateDevPackAnalyzerParams(this.ARSCalculatorParams);
}
//reset subapptype
this.ARSCalculatorParams.SubApplicationType = Constants.SUBAPPLICATION_TYPES.devpacks;
}
this.ARSCalculatorParams.ErrorMessage += this.ARSCalculatorParams.ErrorMessage;
}
else
{
if (this.ARSCalculatorParams.DocToCalcNodeName
== Constants.LINKEDVIEWS_TYPES.linkedviewpack.ToString())
{
//setting default analyzer attribute values
}
else
{
this.ARSCalculatorParams.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_NOFILES");
}
}
}
else
{
this.ARSCalculatorParams.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_NOFILES");
}
return(bHasAnalysis);
}
//add a Machinery1Input to the baseStat.MachineryStocks dictionary
public static bool AddMachinery1StocksToDictionary(
this Machinery1Stock baseStat,
int filePosition, int nodePosition, Machinery1Input calculator)
{
bool bIsAdded = false;
if (filePosition < 0 || nodePosition < 0)
{
baseStat.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_INDEX_OUTOFBOUNDS");
return(false);
}
if (baseStat.MachineryStocks == null)
{
baseStat.MachineryStocks
= new Dictionary <int, List <Machinery1Input> >();
}
if (baseStat.MachineryStocks.ContainsKey(filePosition))
{
if (baseStat.MachineryStocks[filePosition] != null)
{
for (int i = 0; i <= nodePosition; i++)
{
if (baseStat.MachineryStocks[filePosition].Count <= i)
{
baseStat.MachineryStocks[filePosition]
.Add(new Machinery1Input());
}
}
baseStat.MachineryStocks[filePosition][nodePosition]
= calculator;
bIsAdded = true;
}
}
else
{
//add the missing dictionary entry
List <Machinery1Input> baseStats
= new List <Machinery1Input>();
KeyValuePair <int, List <Machinery1Input> > newStat
= new KeyValuePair <int, List <Machinery1Input> >(
filePosition, baseStats);
baseStat.MachineryStocks.Add(newStat);
bIsAdded = AddMachinery1StocksToDictionary(baseStat,
filePosition, nodePosition, calculator);
}
return(bIsAdded);
}
//add a hcOutputfact to the baseStat.HealthCareBenefit1s dictionary
public static bool AddOutputHCStocksToDictionary(this OutputHCStock baseStat,
int filePosition, int nodePosition, HealthBenefit1Calculator hcOutputStock)
{
bool bIsAdded = false;
if (filePosition < 0 || nodePosition < 0)
{
baseStat.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_INDEX_OUTOFBOUNDS");
return(false);
}
if (baseStat.HealthCareBenefit1s == null)
{
baseStat.HealthCareBenefit1s
= new Dictionary <int, List <HealthBenefit1Calculator> >();
}
if (baseStat.HealthCareBenefit1s.ContainsKey(filePosition))
{
if (baseStat.HealthCareBenefit1s[filePosition] != null)
{
for (int i = 0; i <= nodePosition; i++)
{
if (baseStat.HealthCareBenefit1s[filePosition].Count <= i)
{
baseStat.HealthCareBenefit1s[filePosition]
.Add(new HealthBenefit1Calculator());
}
}
baseStat.HealthCareBenefit1s[filePosition][nodePosition]
= hcOutputStock;
bIsAdded = true;
}
}
else
{
//add the missing dictionary entry
List <HealthBenefit1Calculator> baseStats
= new List <HealthBenefit1Calculator>();
KeyValuePair <int, List <HealthBenefit1Calculator> > newStat
= new KeyValuePair <int, List <HealthBenefit1Calculator> >(
filePosition, baseStats);
baseStat.HealthCareBenefit1s.Add(newStat);
bIsAdded = AddOutputHCStocksToDictionary(baseStat,
filePosition, nodePosition, hcOutputStock);
}
return(bIsAdded);
}
//add a foodfact to the baseStat.FoodNutritionStocks dictionary
public static bool AddFNSR01StocksToDictionary(this FNSR01Stock baseStat,
int filePosition, int nodePosition, FNSR01Calculator foodStock)
{
bool bIsAdded = false;
if (filePosition < 0 || nodePosition < 0)
{
baseStat.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_INDEX_OUTOFBOUNDS");
return(false);
}
if (baseStat.FoodNutritionStocks == null)
{
baseStat.FoodNutritionStocks
= new Dictionary <int, List <FNSR01Calculator> >();
}
if (baseStat.FoodNutritionStocks.ContainsKey(filePosition))
{
if (baseStat.FoodNutritionStocks[filePosition] != null)
{
for (int i = 0; i <= nodePosition; i++)
{
if (baseStat.FoodNutritionStocks[filePosition].Count <= i)
{
baseStat.FoodNutritionStocks[filePosition]
.Add(new FNSR01Calculator());
}
}
baseStat.FoodNutritionStocks[filePosition][nodePosition]
= foodStock;
bIsAdded = true;
}
}
else
{
//add the missing dictionary entry
List <FNSR01Calculator> baseStats
= new List <FNSR01Calculator>();
KeyValuePair <int, List <FNSR01Calculator> > newStat
= new KeyValuePair <int, List <FNSR01Calculator> >(
filePosition, baseStats);
baseStat.FoodNutritionStocks.Add(newStat);
bIsAdded = AddFNSR01StocksToDictionary(baseStat,
filePosition, nodePosition, foodStock);
}
return(bIsAdded);
}
//add a base health input stock to the baseStat.BuildCost1s dictionary
public static bool AddSubPrice3StocksToDictionary(this SubPrice3Stock baseStat,
string filePosition, int nodePosition, SubPrice3 indicators)
{
bool bIsAdded = false;
if (string.IsNullOrEmpty(filePosition) || nodePosition < 0)
{
baseStat.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_INDEX_OUTOFBOUNDS");
return(false);
}
if (baseStat.SubPrice3Labels == null)
{
baseStat.SubPrice3Labels
= new Dictionary <string, List <SubPrice3> >();
}
if (baseStat.SubPrice3Labels.ContainsKey(filePosition))
{
if (baseStat.SubPrice3Labels[filePosition] != null)
{
for (int i = 0; i <= nodePosition; i++)
{
if (baseStat.SubPrice3Labels[filePosition].Count <= i)
{
baseStat.SubPrice3Labels[filePosition]
.Add(new SubPrice3());
}
}
baseStat.SubPrice3Labels[filePosition][nodePosition]
= indicators;
bIsAdded = true;
}
}
else
{
//add the missing dictionary entry
List <SubPrice3> baseStats
= new List <SubPrice3>();
KeyValuePair <string, List <SubPrice3> > newStat
= new KeyValuePair <string, List <SubPrice3> >(
filePosition, baseStats);
baseStat.SubPrice3Labels.Add(newStat);
bIsAdded = AddSubPrice3StocksToDictionary(baseStat,
filePosition, nodePosition, indicators);
}
return(bIsAdded);
}
public virtual void SetCostsMemberProperty(int filePosition, int nodePosition,
string attName, string attValue, string nodeName)
{
if (filePosition < 0 || nodePosition < 0)
{
this.CalcParams.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_INDEX_OUTOFBOUNDS");
return;
}
if (this.CalcParams.AnalyzerParms.CostStatistics.ContainsKey(filePosition))
{
if (this.CalcParams.AnalyzerParms.CostStatistics[filePosition] != null)
{
for (int i = 0; i <= nodePosition; i++)
{
if (this.CalcParams.AnalyzerParms.CostStatistics[filePosition].Count <= i)
{
this.CalcParams.AnalyzerParms.CostStatistics[filePosition]
.Add(new CostBenefitStatistic01());
}
}
SetCostStatisticProperty(filePosition, nodePosition,
attName, attValue, nodeName);
if (NeedsBenefitStatsWithCosts(nodeName))
{
//use the costs collection to set a benefits property
SetBenefitStatisticPropertyForCosts(filePosition, nodePosition,
attName, attValue, nodeName);
}
}
else
{
AddCostStatisticsToDictionary(
filePosition, nodePosition, new CostBenefitStatistic01());
SetCostsMemberProperty(filePosition, nodePosition,
attName, attValue, nodeName);
}
}
else
{
AddCostStatisticsToDictionary(
filePosition, nodePosition, new CostBenefitStatistic01());
SetCostsMemberProperty(filePosition, nodePosition,
attName, attValue, nodeName);
}
}
public virtual void AddCostStatisticsToDictionary(
int filePosition, int nodePosition, CostBenefitStatistic01 baseStat)
{
if (filePosition < 0 || nodePosition < 0)
{
this.CalcParams.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_INDEX_OUTOFBOUNDS");
return;
}
if (this.CalcParams.AnalyzerParms.CostStatistics == null)
{
this.CalcParams.AnalyzerParms.CostStatistics
= new Dictionary <int, List <CostBenefitStatistic01> >();
}
if (this.CalcParams.AnalyzerParms.CostStatistics.ContainsKey(filePosition))
{
if (this.CalcParams.AnalyzerParms.CostStatistics[filePosition] != null)
{
for (int i = 0; i <= nodePosition; i++)
{
if (this.CalcParams.AnalyzerParms.CostStatistics[filePosition].Count <= i)
{
this.CalcParams.AnalyzerParms.CostStatistics[filePosition]
.Add(new CostBenefitStatistic01());
}
}
this.CalcParams.AnalyzerParms.CostStatistics[filePosition][nodePosition]
= baseStat;
}
}
else
{
//add the missing dictionary entry
List <CostBenefitStatistic01> baseStats
= new List <CostBenefitStatistic01>();
KeyValuePair <int, List <CostBenefitStatistic01> > newStat
= new KeyValuePair <int, List <CostBenefitStatistic01> >(
filePosition, baseStats);
this.CalcParams.AnalyzerParms.CostStatistics.Add(newStat);
AddCostStatisticsToDictionary(filePosition, nodePosition,
baseStat);
}
}
public static bool SetLinkedListsState(CalculatorParameters calcParameters)
{
bool bIsDone = false;
//step two passes in constants and other lists of data
if (calcParameters.LinkedViewElement != null)
{
AddConstants(CONSTANTS_TYPES.priceconstant,
calcParameters);
//save the tempdoc with changes and bIsDone = true
bIsDone = CalculatorHelpers.SaveNewCalculationsDocument(
calcParameters);
}
else
{
calcParameters.ErrorMessage
= Errors.MakeStandardErrorMsg("CALCSHELPER_FILE_NOTFOUND");
}
return(bIsDone);
}
private bool RunStatisticalCalculation(XElement currentElement)
{
bool bHasCalculations = false;
//1. set parameters needed by updates collection
this.GCCalculatorParams.CurrentElementNodeName
= currentElement.Name.LocalName;
this.GCCalculatorParams.CurrentElementURIPattern
= CalculatorHelpers.MakeNewURIPatternFromElement(
this.GCCalculatorParams.ExtensionDocToCalcURI.URIPattern, currentElement);
//2. carry out calculations
bHasCalculations = RunOperationComponentStatistic(currentElement);
if (!bHasCalculations &&
string.IsNullOrEmpty(this.GCCalculatorParams.ErrorMessage))
{
this.GCCalculatorParams.ErrorMessage
+= Errors.MakeStandardErrorMsg("ANALYSES_CANTRUN");
}
return(bHasCalculations);
}
public bool SetGeneralCapitalStockCalculations(double multiplier,
CalculatorParameters calcParameters, GeneralCapital1Input machInput)
{
bool bHasCalculations = false;
if (machInput != null)
{
//don't adjust machinery per hour costs by any multiplier
//pattern is fine but not appropriate here
//in this extension, calculations are carried out in the
//budget/investment calculators
//BIGeneralCapitalStockCalculator biCalculator = new BIGeneralCapitalStockCalculator();
//biCalculator.ChangeGeneralCapitalInputByMultiplier(machInput, multiplier);
//bHasCalculations = true;
}
else
{
calcParameters.ErrorMessage = Errors.MakeStandardErrorMsg("CALCULATORS_WRONG_ONE");
}
return(bHasCalculations);
}
public ANALYZER_TYPES GetAnalyzerType(string analyzerType)
{
ANALYZER_TYPES eAnalyzerType = ANALYZER_TYPES.none;
if (analyzerType == ANALYZER_TYPES.effectiveness01a.ToString())
{
eAnalyzerType = ANALYZER_TYPES.effectiveness01a;
}
else if (analyzerType == ANALYZER_TYPES.effectiveness01b.ToString())
{
eAnalyzerType = ANALYZER_TYPES.effectiveness01b;
}
else if (analyzerType == ANALYZER_TYPES.effectiveness02a.ToString())
{
eAnalyzerType = ANALYZER_TYPES.effectiveness02a;
}
else if (analyzerType == ANALYZER_TYPES.effectiveness02b.ToString())
{
eAnalyzerType = ANALYZER_TYPES.effectiveness02b;
}
else if (analyzerType == ANALYZER_TYPES.none.ToString())
{
eAnalyzerType = ANALYZER_TYPES.none;
}
else if (analyzerType == ANALYZER_TYPES.resources01.ToString())
{
eAnalyzerType = ANALYZER_TYPES.resources01;
}
else if (analyzerType == ANALYZER_TYPES.statistics01.ToString())
{
eAnalyzerType = ANALYZER_TYPES.statistics01;
}
if (eAnalyzerType == ANALYZER_TYPES.none)
{
this.HCCalculatorParams.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYSES_CHOOSEONE");
}
return(eAnalyzerType);
}
public async Task <bool> DoStepAsync(ContentURI docToCalcURI, ContentURI calcDocURI,
string extensionTypeName, IList <string> urisToAnalyze, IDictionary <string, string> updates,
CancellationToken cancellationToken)
{
bool bIsStepDone = false;
try
{
//extensiontypename (a parameter stored in db) determines
//extension to run
IDoStepsHostMetaData hostview = GetDoStepsView(calcDocURI,
extensionTypeName);
if (hostview != null)
{
//these extensions define their own number of steps internally
string sStepNumber = DataHelpers.AddInHelper.GetStepNumber(docToCalcURI);
//use the view to carry out the current step
bIsStepDone = await RunStepAsync(docToCalcURI, calcDocURI, sStepNumber,
hostview, urisToAnalyze, updates, cancellationToken);
}
else
{
//216: azure bug to release path
docToCalcURI.ErrorMessage = string.Concat(
Errors.MakeStandardErrorMsg("CALCULATORS_MISSING_HOST")
, " ext_typename:", extensionTypeName
, " ext_path:", DataHelpers.AppSettings.GetExtensionsRelPath(calcDocURI)
, " defaultrootpath:", DataHelpers.AppSettings.GetWebContentFullPath(
calcDocURI, "Extensions", "AgBudgetingCalculators.dll")
, " defaultroot_path:", calcDocURI.URIDataManager.DefaultRootFullFilePath);
}
}
catch (Exception x)
{
docToCalcURI.ErrorMessage = x.ToString();
}
return(bIsStepDone);
}
public static ANALYZER_GENERAL_TYPES GetAnalyzerType(
string analyzerType, ref string errorMsg)
{
ANALYZER_GENERAL_TYPES eAnalyzerType = ANALYZER_GENERAL_TYPES.none;
if (analyzerType == ANALYZER_GENERAL_TYPES.basic.ToString())
{
eAnalyzerType = ANALYZER_GENERAL_TYPES.basic;
}
else if (analyzerType == ANALYZER_GENERAL_TYPES.inputbased.ToString())
{
eAnalyzerType = ANALYZER_GENERAL_TYPES.inputbased;
}
else if (analyzerType == ANALYZER_GENERAL_TYPES.outputbased.ToString())
{
eAnalyzerType = ANALYZER_GENERAL_TYPES.outputbased;
}
if (eAnalyzerType == ANALYZER_GENERAL_TYPES.none)
{
errorMsg = Errors.MakeStandardErrorMsg("ANALYSES_CHOOSEONE");
}
return(eAnalyzerType);
}
private bool RunStatisticalCalculation(ref XElement currentElement)
{
bool bHasCalculations = false;
//1. set parameters needed by updates collection
this.GCCalculatorParams.CurrentElementNodeName
= currentElement.Name.LocalName;
this.GCCalculatorParams.CurrentElementURIPattern
= CalculatorHelpers.MakeNewURIPatternFromElement(
this.GCCalculatorParams.ExtensionDocToCalcURI.URIPattern,
currentElement);
GCArguments.CurrentElement = currentElement;
OnRunCalculation(GCArguments);
currentElement = GCArguments.CurrentElement;
bHasCalculations = GCArguments.HasCalculations;
if (!bHasCalculations &&
string.IsNullOrEmpty(this.GCCalculatorParams.ErrorMessage))
{
this.GCCalculatorParams.ErrorMessage
+= Errors.MakeStandardErrorMsg("ANALYSES_CANTRUN");
}
return(bHasCalculations);
}
private void InitCollections(List <TimelinessTimePeriod1> timelinessTimePeriods)
{
if (timelinessTimePeriods != null)
{
if (timelinessTimePeriods.Count > 0)
{
//make the optimization array of uniqueopcomp, feasibleopcomp
MakeOrderedTOCs(timelinessTimePeriods);
if (this.TOpComps == null || this.WOpComps == null)
{
this.ErrorMessage = Errors.GetMessage("RESOURCESTOCKS_NOPOWERORNONPOWERINPUTS");
}
}
else
{
this.ErrorMessage = Errors.GetMessage("RESOURCESTOCKS_NOPOWERORNONPOWERINPUTS");
}
}
else
{
this.ErrorMessage = Errors.GetMessage("RESOURCESTOCKS_NOPOWERORNONPOWERINPUTS");
}
}
public async Task <bool> RunCalculations()
{
bool bHasCalculations = false;
//these calculators use a mix of calculator and analyzer patterns
this.ARSCalculatorParams.RunCalculatorType
= CalculatorHelpers.RUN_CALCULATOR_TYPES.iotechnology;
//urisToAnalyze has the summary calculated results path in position 0.
//This calculator uses that path to derive the full calculated
//results path. The full path document is used to run the calculations
//(it has the input and output calculated results that are
//the basis for most resource stock calculations).
this.ARSCalculatorParams.AnalyzerParms.ObservationsPath
= await CalculatorHelpers.GetFullCalculatorResultsPath(
this.ARSCalculatorParams);
if (!await CalculatorHelpers.URIAbsoluteExists(this.ARSCalculatorParams.ExtensionDocToCalcURI,
this.ARSCalculatorParams.AnalyzerParms.ObservationsPath))
{
this.ARSCalculatorParams.ErrorMessage
= Errors.MakeStandardErrorMsg("ANALYZER_BASECALCS_MISSING");
return(false);
}
//can run npv calcs or base input calculators
if (this.ARSCalculatorParams.CalculatorType
== CalculatorHelpers.CALCULATOR_TYPES.input.ToString() ||
this.ARSCalculatorParams.CalculatorType
== AgBudgetingHelpers.CALCULATOR_TYPES.agmachinery.ToString() ||
this.ARSCalculatorParams.CalculatorType
== AgBudgetingHelpers.CALCULATOR_TYPES.irrpower.ToString() ||
this.ARSCalculatorParams.CalculatorType
== AgBudgetingHelpers.CALCULATOR_TYPES.gencapital.ToString())
{
IOMachineryStockSubscriber subInput
= new IOMachineryStockSubscriber(this.ARSCalculatorParams);
bHasCalculations = await subInput.RunCalculator();
CalculatorHelpers.UpdateCalculatorParams(this.ARSCalculatorParams,
subInput.GCCalculatorParams);
subInput = null;
}
else if (this.ARSCalculatorParams.CalculatorType.StartsWith(
CalculatorHelpers.CALCULATOR_TYPES.operation.ToString()) ||
this.ARSCalculatorParams.CalculatorType.StartsWith(
CalculatorHelpers.CALCULATOR_TYPES.component.ToString()))
{
OCMachineryStockSubscriber subOperation
= new OCMachineryStockSubscriber(this.ARSCalculatorParams);
bHasCalculations = await subOperation.RunCalculator();
CalculatorHelpers.UpdateCalculatorParams(this.ARSCalculatorParams,
subOperation.GCCalculatorParams);
subOperation = null;
}
else if (this.ARSCalculatorParams.CalculatorType
== CalculatorHelpers.CALCULATOR_TYPES.budget.ToString() ||
this.ARSCalculatorParams.CalculatorType
== CalculatorHelpers.CALCULATOR_TYPES.investment.ToString())
{
BIMachineryStockSubscriber subBudget
= new BIMachineryStockSubscriber(this.ARSCalculatorParams);
bHasCalculations = await subBudget.RunCalculator();
CalculatorHelpers.UpdateCalculatorParams(this.ARSCalculatorParams,
subBudget.GCCalculatorParams);
subBudget = null;
}
return(bHasCalculations);
}
//allows derived classes to override the default streaming
//and save method
protected virtual bool StreamAndSaveObservation()
{
HasGoodObservationFile = false;
if (this.ObsCalculatorParams.AnalyzerParms.FileOrFolderPaths == null)
{
this.ObsCalculatorParams.ErrorMessage
= Errors.MakeStandardErrorMsg("OBSERVATIONS_NOFILES_SAVETEXT");
return(false);
}
else
{
if (this.ObsCalculatorParams.AnalyzerParms.FileOrFolderPaths.Count <= 0)
{
this.ObsCalculatorParams.ErrorMessage
= Errors.MakeStandardErrorMsg("OBSERVATIONS_NOFILES_SAVETEXT");
return(false);
}
}
bool bHasInitialColumnDictionary = InitColumnDictionary();
this.ObsCalculatorParams.AnalyzerParms.ObservationsPath
= GetObservationFilePath(this.ObsCalculatorParams.ExtensionDocToCalcURI.URIDataManager.TempDocPath);
if (!string.IsNullOrEmpty(this.ObsCalculatorParams.AnalyzerParms.ObservationsPath))
{
if (bHasInitialColumnDictionary)
{
TextFile = new StreamWriter(
this.ObsCalculatorParams.AnalyzerParms.ObservationsPath);
//write the column headings
WriteColumnNameRow();
}
//+1 because the first column holds the stats for all comparisons
//int iFileComparisonsCount = fileOrFolderPaths.Count + 1;
//subscribers set a "Files" attribute property using this property
this.ObsCalculatorParams.AnalyzerParms.FilesComparisonsCount
= this.ObsCalculatorParams.AnalyzerParms.FileOrFolderPaths.Count + 1;
string sId = string.Empty;
string sFileToAnalyze = string.Empty;
int i = 0;
//file order is not relevant in this addin,
//but parallel won't work (yet) because of the way
//the observationRoot gets built
foreach (KeyValuePair <string, string> kvp
in this.ObsCalculatorParams.AnalyzerParms.FileOrFolderPaths)
{
sId = kvp.Key;
sFileToAnalyze = kvp.Value;
if (CalculatorHelpers.URIAbsoluteExists(
this.ObsCalculatorParams.ExtensionDocToCalcURI,
sFileToAnalyze))
{
this.ObsCalculatorParams.AnalyzerParms.ObservationFile = sFileToAnalyze;
this.ObsCalculatorParams.AnalyzerParms.FilePositionIndex = i;
//stream and add the calculation (observation)
//to the observationsRoot
if (!CalculatorHelpers.URIAbsoluteExists(
this.ObsCalculatorParams.ExtensionDocToCalcURI,
this.ObsCalculatorParams.AnalyzerParms.ObservationFile))
{
return(HasGoodObservationFile);
}
this.ObsCalculatorParams.DocToCalcReader
= DevTreks.Data.Helpers.FileStorageIO.GetXmlReader(
this.ObsCalculatorParams.ExtensionDocToCalcURI.URIDataManager.InitialDocToCalcURI,
this.ObsCalculatorParams.AnalyzerParms.ObservationFile);
if (this.ObsCalculatorParams.DocToCalcReader != null)
{
using (this.ObsCalculatorParams.DocToCalcReader)
{
this.ObsCalculatorParams.DocToCalcReader.MoveToContent();
this.ObsCalculatorParams.AnalyzerParms.Ancestors.Clear();
this.ObsCalculatorParams.CurrentElementNodeName
= string.Empty;
this.ObsCalculatorParams.ParentElementNodeName
= string.Empty;
LinkedViewCount = 0;
AddObservations(bHasInitialColumnDictionary);
}
}
if (this.ObsCalculatorParams.ErrorMessage != string.Empty)
{
//fix all errors before running an analysis
this.ObsCalculatorParams.ErrorMessage
= this.ObsCalculatorParams.ErrorMessage;
break;
}
i++;
}
}
if (this.ObsCalculatorParams.ErrorMessage == string.Empty)
{
if (bHasInitialColumnDictionary)
{
//save the observations file
if (TextFile != null)
{
//2 passes means using syntax can't be used
TextFile.Flush();
TextFile.Close();
HasGoodObservationFile = true;
}
}
else
{
//second pass builds the observations
StreamAndSaveObservation();
}
}
}
return(HasGoodObservationFile);
}
public bool SetFNSRStockCalculations(double multiplier,
CalculatorParameters calcParameters, FNSR01Calculator foodNutSR)
{
bool bHasCalculations = false;
if (foodNutSR != null)
{
foodNutSR.ActualWater_g = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Water_g);
foodNutSR.ActualEnerg_Kcal = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Energ_Kcal);
foodNutSR.ActualProtein_g = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Protein_g);
foodNutSR.ActualLipid_Tot_g = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Lipid_Tot_g);
foodNutSR.ActualAsh_g = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Ash_g);
foodNutSR.ActualCarbohydrt_g = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Carbohydrt_g);
foodNutSR.ActualFiber_TD_g = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Fiber_TD_g);
foodNutSR.ActualSugar_Tot_g = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Sugar_Tot_g);
foodNutSR.ActualCalcium_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Calcium_mg);
foodNutSR.ActualIron_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Iron_mg);
foodNutSR.ActualMagnesium_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Magnesium_mg);
foodNutSR.ActualPhosphorus_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Phosphorus_mg);
foodNutSR.ActualPotassium_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Potassium_mg);
foodNutSR.ActualSodium_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Sodium_mg);
foodNutSR.ActualZinc_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Zinc_mg);
foodNutSR.ActualCopper_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Copper_mg);
foodNutSR.ActualManganese_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Manganese_mg);
foodNutSR.ActualSelenium_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Selenium_pg);
foodNutSR.ActualVit_C_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Vit_C_mg);
foodNutSR.ActualThiamin_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Thiamin_mg);
foodNutSR.ActualRiboflavin_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Riboflavin_mg);
foodNutSR.ActualNiacin_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Niacin_mg);
foodNutSR.ActualPanto_Acid_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Panto_Acid_mg);
foodNutSR.ActualVit_B6_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Vit_B6_mg);
foodNutSR.ActualFolate_Tot_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Folate_Tot_pg);
foodNutSR.ActualFolic_Acid_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Folic_Acid_pg);
foodNutSR.ActualFood_Folate_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Food_Folate_pg);
foodNutSR.ActualFolate_DFE_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Folate_DFE_pg);
foodNutSR.ActualCholine_Tot_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Choline_Tot_mg);
foodNutSR.ActualVit_B12_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Vit_B12_pg);
foodNutSR.ActualVit_A_IU = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Vit_A_IU);
foodNutSR.ActualVit_A_RAE = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Vit_A_RAE);
foodNutSR.ActualRetinol_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Retinol_pg);
foodNutSR.ActualAlpha_Carot_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Alpha_Carot_pg);
foodNutSR.ActualBeta_Carot_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Beta_Carot_pg);
foodNutSR.ActualBeta_Crypt_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Beta_Crypt_pg);
foodNutSR.ActualLycopene_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Lycopene_pg);
foodNutSR.ActualLut_Zea_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Lut_Zea_pg);
foodNutSR.ActualVit_E_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Vit_E_mg);
foodNutSR.ActualVit_D_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Vit_D_pg);
foodNutSR.ActualViVit_D_IU = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.ViVit_D_IU);
foodNutSR.ActualVit_K_pg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Vit_K_pg);
foodNutSR.ActualFA_Sat_g = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.FA_Sat_g);
foodNutSR.ActualFA_Mono_g = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.FA_Mono_g);
foodNutSR.ActualFA_Poly_g = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.FA_Poly_g);
foodNutSR.ActualCholestrl_mg = GetActualFoodNutrientProperty(foodNutSR, foodNutSR.Cholestrl_mg);
SetFoodNutritionInputCosts(calcParameters, ref foodNutSR);
bHasCalculations = true;
}
else
{
calcParameters.ErrorMessage = Errors.MakeStandardErrorMsg("CALCULATORS_WRONG_ONE");
}
return(bHasCalculations);
}
//kept for consistency with Extension pattern, but NPV calculators use the NPVCalcs extension
public async Task <bool> RunCalculatorStep(
ExtensionContentURI extDocToCalcURI, ExtensionContentURI extCalcDocURI,
string stepNumber, IList <string> urisToAnalyze,
IDictionary <string, string> updates, CancellationToken cancellationToken)
{
bool bHasCalculation = false;
CalculatorHelpers eCalcHelpers = new CalculatorHelpers();
CalculatorParameters NPV1CalcParams
= CalculatorHelpers.SetCalculatorParameters(
extDocToCalcURI, extCalcDocURI, stepNumber, urisToAnalyze,
updates);
NPV1CalculatorHelper npv1BudgetHelper
= new NPV1CalculatorHelper(NPV1CalcParams);
ContractHelpers.EXTENSION_STEPS eStepNumber
= ContractHelpers.GetEnumStepNumber(stepNumber);
bool bHasUpdates = false;
switch (eStepNumber)
{
case ContractHelpers.EXTENSION_STEPS.stepzero:
bHasCalculation = true;
break;
case ContractHelpers.EXTENSION_STEPS.stepone:
bHasCalculation = true;
break;
case ContractHelpers.EXTENSION_STEPS.steptwo:
//clear updates collection
updates.Clear();
if (NPV1CalcParams != null)
{
//set constants for this step
bHasCalculation
= await NPV1CalculatorHelper.SetConstants(NPV1CalcParams);
}
extDocToCalcURI.URIDataManager.NeedsFullView = false;
extDocToCalcURI.URIDataManager.NeedsSummaryView = false;
break;
case ContractHelpers.EXTENSION_STEPS.stepthree:
//get rid of any update member that was added after running the same step 2x
bHasUpdates = await CalculatorHelpers.RefreshUpdates(NPV1CalcParams, stepNumber, updates);
if (NPV1CalcParams != null)
{
//no constants; just an xml edit of NRImpacts
bHasCalculation = true;
}
extDocToCalcURI.URIDataManager.NeedsFullView = false;
extDocToCalcURI.URIDataManager.NeedsSummaryView = false;
break;
case ContractHelpers.EXTENSION_STEPS.stepfour:
//get rid of any update member that was added after running the same step 2x
bHasUpdates = await CalculatorHelpers.RefreshUpdates(NPV1CalcParams, stepNumber, updates);
if (NPV1CalcParams != null)
{
if (NPV1CalcParams.ExtensionDocToCalcURI.URIDataManager.SubAppType
!= Constants.SUBAPPLICATION_TYPES.devpacks.ToString())
{
//run the calculations
bHasCalculation = await npv1BudgetHelper.RunNPV1CalculatorCalculations();
}
else
{
//run custom document calculations
bHasCalculation
= await npv1BudgetHelper.RunDevPacksCalculations(NPV1CalcParams);
}
extDocToCalcURI.ErrorMessage = NPV1CalcParams.ErrorMessage;
extDocToCalcURI.ErrorMessage += NPV1CalcParams.ExtensionDocToCalcURI.ErrorMessage;
if (!bHasCalculation)
{
extDocToCalcURI.ErrorMessage = (extDocToCalcURI.ErrorMessage == string.Empty) ?
Errors.MakeStandardErrorMsg("CALCULATORS_URI_MISMATCH")
: extDocToCalcURI.ErrorMessage;
return(bHasCalculation);
}
if (string.IsNullOrEmpty(extDocToCalcURI.ErrorMessage))
{
//two step calculators need to be saved now
CheckForLastStepCalculator(NPV1CalcParams,
eStepNumber, extDocToCalcURI);
//replace the old calculator with the new one
//and save the new calculations document
bHasCalculation
= await CalculatorHelpers.SaveNewCalculationsDocument(NPV1CalcParams);
}
else
{
bHasCalculation = false;
}
}
extDocToCalcURI.URIDataManager.NeedsFullView = true;
extDocToCalcURI.URIDataManager.NeedsSummaryView = false;
break;
case ContractHelpers.EXTENSION_STEPS.stepfive:
extDocToCalcURI.URIDataManager.NeedsFullView = false;
extDocToCalcURI.URIDataManager.NeedsSummaryView = true;
extCalcDocURI.URIFileExtensionType = CalculatorHelpers.GetAttribute(NPV1CalcParams.LinkedViewElement,
Calculator1.cFileExtensionType);
bHasCalculation = true;
//tells addinhelper to save calcs
CalculatorHelpers.SetTempDocSaveCalcsProperty(extDocToCalcURI);
break;
default:
//as many steps as needed can be added to this addin
break;
}
extDocToCalcURI.ErrorMessage += NPV1CalcParams.ErrorMessage;
return(bHasCalculation);
}
public async Task <bool> RunAnalyzerStep(
ExtensionContentURI extDocToCalcURI, ExtensionContentURI extCalcDocURI,
string stepNumber, IList <string> urisToAnalyze,
IDictionary <string, string> updates, CancellationToken cancellationToken)
{
bool bHasAnalysis = false;
CalculatorParameters npv1CalcParams
= CalculatorHelpers.SetCalculatorParameters(
extDocToCalcURI, extCalcDocURI, stepNumber, urisToAnalyze,
updates);
NPV1AnalyzerHelper npv1AnalyzerHelper = new NPV1AnalyzerHelper(npv1CalcParams);
//check to make sure the analyzer can be run
npv1AnalyzerHelper.SetOptions();
bool bHasUpdates = false;
if (npv1AnalyzerHelper.NPV1CalculatorParams.ErrorMessage != string.Empty)
{
extDocToCalcURI.ErrorMessage += npv1AnalyzerHelper.NPV1CalculatorParams.ErrorMessage;
return(false);
}
ContractHelpers.EXTENSION_STEPS eStepNumber
= ContractHelpers.GetEnumStepNumber(stepNumber);
switch (eStepNumber)
{
case ContractHelpers.EXTENSION_STEPS.stepzero:
bHasAnalysis = true;
break;
case ContractHelpers.EXTENSION_STEPS.stepone:
bHasAnalysis = true;
break;
case ContractHelpers.EXTENSION_STEPS.steptwo:
//clear updates collection
updates.Clear();
//just need the html form edits in this step
bHasAnalysis = true;
extDocToCalcURI.URIDataManager.NeedsFullView = false;
extDocToCalcURI.URIDataManager.NeedsSummaryView = false;
break;
case ContractHelpers.EXTENSION_STEPS.stepthree:
//get rid of any update member that was added after running the same step 2x
bHasUpdates = await CalculatorHelpers.RefreshUpdates(npv1CalcParams, stepNumber, updates);
//linked view insertions needs some analysis parameters
SetAnalyzerParameters(npv1AnalyzerHelper, npv1CalcParams);
if (npv1CalcParams.SubApplicationType == Constants.SUBAPPLICATION_TYPES.devpacks)
{
bHasAnalysis = await npv1AnalyzerHelper.RunAnalysis(npv1CalcParams.UrisToAnalyze);
}
else
{
bHasAnalysis = await npv1AnalyzerHelper.RunAnalysis();
}
extDocToCalcURI.ErrorMessage = npv1CalcParams.ErrorMessage;
extDocToCalcURI.ErrorMessage += npv1AnalyzerHelper.NPV1CalculatorParams.ErrorMessage;
if (!bHasAnalysis)
{
extDocToCalcURI.ErrorMessage = (extDocToCalcURI.ErrorMessage == string.Empty) ?
Errors.MakeStandardErrorMsg("CALCULATORS_URI_MISMATCH")
: extDocToCalcURI.ErrorMessage;
return(bHasAnalysis);
}
if (string.IsNullOrEmpty(extDocToCalcURI.ErrorMessage))
{
//two step analyzers need to be saved now
NPV1AnalyzerHelper.ANALYZER_TYPES eAnalyzerType
= npv1AnalyzerHelper.GetAnalyzerType(
npv1AnalyzerHelper.NPV1CalculatorParams.AnalyzerParms.AnalyzerType);
//when 3+ step analyzers start being used
CheckForLastStepAnalyzer(eAnalyzerType,
eStepNumber, extDocToCalcURI);
if (!CalculatorHelpers.IsSaveAction(extDocToCalcURI))
{
//replace the old calculator with the new one
//and save the new calculations document
bool bHasReplacedCalcDoc
= await CalculatorHelpers.SaveNewCalculationsDocument(
npv1AnalyzerHelper.NPV1CalculatorParams);
if (bHasReplacedCalcDoc)
{
bHasAnalysis = true;
}
else
{
extDocToCalcURI.ErrorMessage = Errors.MakeStandardErrorMsg("ANALYSES_ID_MISMATCH");
}
}
}
else
{
bHasAnalysis = false;
}
extDocToCalcURI.URIDataManager.NeedsFullView = true;
extDocToCalcURI.URIDataManager.NeedsSummaryView = false;
break;
case ContractHelpers.EXTENSION_STEPS.stepfour:
bHasAnalysis = true;
if (npv1AnalyzerHelper.AnalyzerType
== NPV1AnalyzerHelper.ANALYZER_TYPES.npvtotal1 ||
npv1AnalyzerHelper.AnalyzerType
== NPV1AnalyzerHelper.ANALYZER_TYPES.npvstat1 ||
npv1AnalyzerHelper.AnalyzerType
== NPV1AnalyzerHelper.ANALYZER_TYPES.npvchangeyr ||
npv1AnalyzerHelper.AnalyzerType
== NPV1AnalyzerHelper.ANALYZER_TYPES.npvchangeid ||
npv1AnalyzerHelper.AnalyzerType
== NPV1AnalyzerHelper.ANALYZER_TYPES.npvchangealt ||
npv1AnalyzerHelper.AnalyzerType
== NPV1AnalyzerHelper.ANALYZER_TYPES.npvprogress1)
{
if (npv1CalcParams.NeedsFullView)
{
extDocToCalcURI.URIDataManager.NeedsFullView = true;
extDocToCalcURI.URIDataManager.NeedsSummaryView = false;
}
else
{
extDocToCalcURI.URIDataManager.NeedsFullView = false;
extDocToCalcURI.URIDataManager.NeedsSummaryView = true;
}
extCalcDocURI.URIFileExtensionType = CalculatorHelpers.GetAttribute(npv1CalcParams.LinkedViewElement,
Calculator1.cFileExtensionType);
}
if (extDocToCalcURI.URIDataManager.TempDocSaveMethod
== Constants.SAVECALCS_METHOD.saveastext.ToString())
{
//analyzers aren't yet available
}
else
{
//tells addinhelper to save calcs
CalculatorHelpers.SetTempDocSaveAnalysesProperty(extDocToCalcURI);
}
break;
default:
//as many steps as needed can be added to this addin
break;
}
extDocToCalcURI.ErrorMessage += npv1AnalyzerHelper.NPV1CalculatorParams.ErrorMessage;
return(bHasAnalysis);
}
public async Task <bool> RunAnalyzerStep(
ExtensionContentURI extDocToCalcURI, ExtensionContentURI extCalcDocURI,
string stepNumber, IList <string> urisToAnalyze,
IDictionary <string, string> updates, CancellationToken cancellationToken)
{
bool bHasAnalysis = false;
CalculatorParameters fnCalcParams
= CalculatorHelpers.SetCalculatorParameters(
extDocToCalcURI, extCalcDocURI, stepNumber, urisToAnalyze,
updates);
FNAnalyzerHelper fnAnalyzerHelper = new FNAnalyzerHelper(fnCalcParams);
//check to make sure the analyzer can be run
fnAnalyzerHelper.SetOptions();
if (fnAnalyzerHelper.FNCalculatorParams.ErrorMessage != string.Empty)
{
extDocToCalcURI.ErrorMessage += fnAnalyzerHelper.FNCalculatorParams.ErrorMessage;
return(false);
}
ContractHelpers.EXTENSION_STEPS eStepNumber
= ContractHelpers.GetEnumStepNumber(stepNumber);
bool bHasUpdates = false;
switch (eStepNumber)
{
case ContractHelpers.EXTENSION_STEPS.stepzero:
bHasAnalysis = true;
break;
case ContractHelpers.EXTENSION_STEPS.stepone:
bHasAnalysis = true;
break;
case ContractHelpers.EXTENSION_STEPS.steptwo:
//clear updates collection
updates.Clear();
//just need the html form edits in this step
bHasAnalysis = true;
extDocToCalcURI.URIDataManager.NeedsFullView = false;
extDocToCalcURI.URIDataManager.NeedsSummaryView = false;
break;
case ContractHelpers.EXTENSION_STEPS.stepthree:
//get rid of any update member that was added after running the same step 2x
bHasUpdates = await CalculatorHelpers.RefreshUpdates(fnCalcParams, stepNumber, updates);
if (fnAnalyzerHelper.AnalyzerType
== FNAnalyzerHelper.ANALYZER_TYPES.resources01)
{
//linked view insertions needs some analysis parameters
SetAnalyzerParameters(fnAnalyzerHelper, fnCalcParams);
//the calculator pattern handles children linked view insertions
//better than the analyzer pattern
FNCalculatorHelper fnCalculatorHelper
= new FNCalculatorHelper(fnCalcParams);
bHasAnalysis = await fnCalculatorHelper.RunCalculations();
}
else
{
//run the analysis (when analyses are available)
//bHasAnalysis = fnAnalyzerHelper
// .RunAnalysis(urisToAnalyze);
}
extDocToCalcURI.ErrorMessage = fnCalcParams.ErrorMessage;
extDocToCalcURI.ErrorMessage += fnAnalyzerHelper.FNCalculatorParams.ErrorMessage;
if (!bHasAnalysis)
{
extDocToCalcURI.ErrorMessage = (extDocToCalcURI.ErrorMessage == string.Empty) ?
Errors.MakeStandardErrorMsg("CALCULATORS_URI_MISMATCH")
: extDocToCalcURI.ErrorMessage;
return(bHasAnalysis);
}
if (string.IsNullOrEmpty(extDocToCalcURI.ErrorMessage))
{
//two step analyzers need to be saved now
FNAnalyzerHelper.ANALYZER_TYPES eAnalyzerType
= fnAnalyzerHelper.GetAnalyzerType(
fnAnalyzerHelper.FNCalculatorParams.AnalyzerParms.AnalyzerType);
//when 3+ step analyzers start being used
CheckForLastStepAnalyzer(eAnalyzerType,
eStepNumber, extDocToCalcURI);
if (!CalculatorHelpers.IsSaveAction(extDocToCalcURI))
{
//replace the old calculator with the new one
//and save the new calculations document
bool bHasReplacedCalcDoc
= await CalculatorHelpers.SaveNewCalculationsDocument(
fnAnalyzerHelper.FNCalculatorParams);
if (bHasReplacedCalcDoc)
{
//the resource01 app uses the calculator, rather
//than analyzer, pattern (i.e. children linked views
//can be inserted)
if (fnAnalyzerHelper.AnalyzerType
!= FNAnalyzerHelper.ANALYZER_TYPES.resources01)
{
//and add xmldoc params to update collection
//only doctocalc gets updated
CalculatorHelpers.AddXmlDocAndXmlDocIdsToUpdates(
fnAnalyzerHelper.FNCalculatorParams);
}
bHasAnalysis = true;
}
else
{
extDocToCalcURI.ErrorMessage = Errors.MakeStandardErrorMsg("ANALYSES_ID_MISMATCH");
}
}
}
else
{
bHasAnalysis = false;
}
extDocToCalcURI.URIDataManager.NeedsFullView = true;
extDocToCalcURI.URIDataManager.NeedsSummaryView = false;
break;
case ContractHelpers.EXTENSION_STEPS.stepfour:
bHasAnalysis = true;
if (fnAnalyzerHelper.AnalyzerType
== FNAnalyzerHelper.ANALYZER_TYPES.resources01)
{
extDocToCalcURI.URIDataManager.NeedsFullView = false;
extDocToCalcURI.URIDataManager.NeedsSummaryView = true;
extCalcDocURI.URIFileExtensionType = CalculatorHelpers.GetAttribute(fnCalcParams.LinkedViewElement,
Calculator1.cFileExtensionType);
}
if (extDocToCalcURI.URIDataManager.TempDocSaveMethod
== Constants.SAVECALCS_METHOD.saveastext.ToString())
{
//analyzers aren't yet available
}
else
{
//tells addinhelper to save calcs
CalculatorHelpers.SetTempDocSaveAnalysesProperty(extDocToCalcURI);
}
break;
default:
//as many steps as needed can be added to this addin
break;
}
extDocToCalcURI.ErrorMessage += fnAnalyzerHelper.FNCalculatorParams.ErrorMessage;
return(bHasAnalysis);
}
public async Task <bool> RunSubAlgorithm3Async(string inputFile1Path, string inputFile2Path)
{
bool bHasCalcs = false;
string sBaseURL =
"https://ussouthcentral.services.azureml.net/workspaces/d454361ecdcb4ec4b03fa1aec5a7c0e2/services/8b1074b465ea4258a11ec48ce64ae257/jobs";
string sPlatForm = CalculatorHelpers.GetPlatform(_params.ExtensionDocToCalcURI, inputFile1Path);
if (sPlatForm != CalculatorHelpers.PLATFORM_TYPES.azure.ToString())
{
sBaseURL = "https://ussouthcentral.services.azureml.net/workspaces/d454361ecdcb4ec4b03fa1aec5a7c0e2/services/8b1074b465ea4258a11ec48ce64ae257/execute?api-version=2.0&details=true";
}
string sApiKey =
"RO2Ev5dRSKqNJ4jz+zoT0qDntEsKbyizbgZKlhOR2vGztsjBD3S3C8nmIlZI9TbbmCcsw+unwhky1GgZ5qiHmg==";
string sError = string.Empty;
//web server expects to store in temp/randomid/name.csv
//scoring results
string sOutputData1URL = CalculatorHelpers.GetTempContainerPath("outputdata1.csv");
//model results
string sOutputData2URL = CalculatorHelpers.GetTempContainerPath("outputdata2.csv");
//web service expects urls that start with container names
string sInput1ContainerPath = CalculatorHelpers.GetContainerPathFromFullURIPath("resources", inputFile1Path);
string sInput2ContainerPath = CalculatorHelpers.GetContainerPathFromFullURIPath("resources", inputFile2Path);
//async wait so that results can be stored in output file location and parsed into string lines
SetResponse2(sBaseURL, sApiKey, sInput1ContainerPath, sInput2ContainerPath, sOutputData1URL, sOutputData2URL).Wait();
StringBuilder sb = new StringBuilder();
//if web service successully saved the results, the response will start with Success
if (_response.StartsWith("Success"))
{
//return the output file contents in a string list of lines
//must convert container path to full path
string sOutput1FullDataURL = string.Concat("https://devtreks1.blob.core.windows.net/", sOutputData1URL);
List <string> lines = new List <string>();
//azure emulator can't process real Azure URL so this won't work
//instead, double check that output url is actually saved
lines = CalculatorHelpers.ReadLines(_params.ExtensionDocToCalcURI, sOutput1FullDataURL, out sError);
this.ErrorMessage += sError;
//this results in endless wait
//lines = await CalculatorHelpers.ReadLinesAsync(sOutputDataURL);
if (lines == null)
{
this.ErrorMessage += string.Concat(" ", Errors.MakeStandardErrorMsg("DATAURL_BAD"));
return(bHasCalcs);
}
if (lines.Count == 0)
{
this.ErrorMessage += string.Concat(" ", Errors.MakeStandardErrorMsg("DATAURL_BAD"));
return(bHasCalcs);
}
sb = new StringBuilder();
sb.AppendLine("aml results");
//dep var has to be in the R project 1st column
//string sLine = string.Concat("first variable: ", _colNames[0]);
string[] line = new List <string>().ToArray();
int iPos = 0;
for (int i = 0; i < lines.Count(); i++)
{
line = lines[i].Split(Constants.CSV_DELIMITERS);
//lineout[1] = CalculatorHelpers.ConvertStringToDouble(line[0]).ToString("N4", CultureInfo.InvariantCulture);
sb.AppendLine(Shared.GetLine(line, false));
}
if (this.MathResult.ToLower().StartsWith("http"))
{
sError = string.Empty;
bool bHasSaved = CalculatorHelpers.SaveTextInURI(
_params.ExtensionDocToCalcURI, sb.ToString(), this.MathResult, out sError);
if (!string.IsNullOrEmpty(sError))
{
this.MathResult += sError;
}
}
else
{
this.MathResult = sb.ToString();
}
bHasCalcs = true;
//last line of string should have the QTM vars
if (line != null)
{
//last string is prediction
iPos = line.Count() - 1;
//int iPos = line.Count() - 3;
if (line[iPos] != null)
{
this.QTPredicted = CalculatorHelpers.ConvertStringToDouble(line[iPos]);
}
}
string sOutput2FullDataURL = string.Concat("https://devtreks1.blob.core.windows.net/", sOutputData2URL);
lines = new List <string>();
//azure emulator can't process real Azure URL so this won't work
//instead, double check that output url is actually saved
lines = CalculatorHelpers.ReadLines(_params.ExtensionDocToCalcURI, sOutput2FullDataURL, out sError);
this.ErrorMessage += sError;
if (lines == null)
{
this.ErrorMessage += string.Concat(" ", Errors.MakeStandardErrorMsg("DATAURL_BAD"));
return(bHasCalcs);
}
if (lines.Count == 0)
{
this.ErrorMessage += string.Concat(" ", Errors.MakeStandardErrorMsg("DATAURL_BAD"));
return(bHasCalcs);
}
sb = new StringBuilder();
//dep var has to be in the R project 1st column
//string sLine = string.Concat("first variable: ", _colNames[0]);
line = new List <string>().ToArray();
double dbCI = 0;
for (int i = 0; i < lines.Count(); i++)
{
line = lines[i].Split(Constants.CSV_DELIMITERS);
if (line != null)
{
iPos = 0;
//used to derive conf interval
dbCI = CalculatorHelpers.ConvertStringToDouble(line[iPos]);
sb.AppendLine(string.Format("{0} {1}", "Mean Absolute Error: ", dbCI.ToString()));
double dbScore = 0;
if (line.Count() >= 2)
{
iPos = 1;
dbScore = CalculatorHelpers.ConvertStringToDouble(line[iPos]);
sb.AppendLine(string.Format("{0} {1}", "Root Mean Squared Error: ", dbScore.ToString()));
}
if (line.Count() >= 3)
{
iPos = 2;
dbScore = CalculatorHelpers.ConvertStringToDouble(line[iPos]);
sb.AppendLine(string.Format("{0} {1}", "Relative Absolute Error: ", dbScore.ToString()));
}
if (line.Count() >= 4)
{
iPos = 3;
dbScore = CalculatorHelpers.ConvertStringToDouble(line[iPos]);
sb.AppendLine(string.Format("{0} {1}", "Relative Squared Error: ", dbScore.ToString()));
}
if (line.Count() >= 5)
{
iPos = 4;
dbScore = CalculatorHelpers.ConvertStringToDouble(line[iPos]);
sb.AppendLine(string.Format("{0} {1}", "Coefficient of Determination: ", dbScore.ToString()));
}
//sb.AppendLine(Shared.GetLine(line, false));
}
}
this.MathResult += sb.ToString();
bHasCalcs = true;
//last line of string should have the QTM vars
if (line != null)
{
if (line[iPos] != null)
{
dbCI = CalculatorHelpers.ConvertStringToDouble(line[iPos]);
}
this.QTL = this.QTPredicted - dbCI;
this.QTU = this.QTPredicted + dbCI;
}
}
else
{
this.ErrorMessage += "The calculations could not be run using the web service.";
}
return(bHasCalcs);
}
public async Task <bool> RunSubAlgorithm1or2Async(string inputFilePath, string rFile)
{
bool bHasCalcs = false;
string sBaseURL =
"https://ussouthcentral.services.azureml.net/workspaces/d454361ecdcb4ec4b03fa1aec5a7c0e2/services/b10e6b4c4e63438999cc45147bbe006c/jobs";
if (_subalgorithm == Calculator1.MATH_SUBTYPES.subalgorithm2.ToString())
{
sBaseURL = "https://ussouthcentral.services.azureml.net/workspaces/d454361ecdcb4ec4b03fa1aec5a7c0e2/services/abd32060dc014d0e8fe1256e0f694daa/jobs";
}
string sPlatForm = _params.ExtensionDocToCalcURI.URIDataManager.PlatformType.ToString();
if (sPlatForm != CalculatorHelpers.PLATFORM_TYPES.azure.ToString())
{
sBaseURL = "https://ussouthcentral.services.azureml.net/workspaces/d454361ecdcb4ec4b03fa1aec5a7c0e2/services/b10e6b4c4e63438999cc45147bbe006c/execute?api-version=2.0&details=true";
if (_subalgorithm == Calculator1.MATH_SUBTYPES.subalgorithm2.ToString())
{
sBaseURL = "https://ussouthcentral.services.azureml.net/workspaces/d454361ecdcb4ec4b03fa1aec5a7c0e2/services/abd32060dc014d0e8fe1256e0f694daa/execute?api-version=2.0&details=true";
}
}
//r web service is default
string sApiKey =
"fxBeL9LJ3ORm0kW0DtKhT99OfUK6YgBlc59crizYhlxKoEjRd3kuDHvPRuehCQ02VJhPPXcdYTp2pDUynb9gMA==";
if (_subalgorithm == Calculator1.MATH_SUBTYPES.subalgorithm2.ToString())
{
//python
sApiKey =
"/bjDNKx4OWdMIQu6CkvWCIhcfUOCTp9jUE9kD7uylwhOYyhVFOqAFA7M75mJjHS6p6jnAhCvFn1jSl678gzPVA==";
}
string sError = string.Empty;
//convert the script file to the script string expected by the algorithm
List <string> rlines = new List <string>();
rlines = CalculatorHelpers.ReadLines(_params.ExtensionDocToCalcURI, rFile, out sError);
this.ErrorMessage += sError;
if (rlines == null)
{
this.ErrorMessage += string.Concat(" ", Errors.MakeStandardErrorMsg("DATAURL_BAD"));
return(bHasCalcs);
}
if (rlines.Count == 0)
{
this.ErrorMessage += string.Concat(" ", Errors.MakeStandardErrorMsg("DATAURL_BAD"));
return(bHasCalcs);
}
StringBuilder sbR = new StringBuilder();
for (int i = 0; i < rlines.Count(); i++)
{
sbR.AppendLine(rlines[i]);
}
string rScript = sbR.ToString();
//web server expects to store in temp/randomid/name.csv
//web service stores in temp blob
string sOutputDataURL = CalculatorHelpers.GetTempContainerPath("Routput.csv");
//web service expects urls that start with container names
//regular rproject file must be stored in JDataURL
string sInputContainerPath = CalculatorHelpers.GetContainerPathFromFullURIPath("resources", inputFilePath);
//async wait so that results can be stored in output file location and parsed into string lines
SetResponse(sBaseURL, sApiKey, sInputContainerPath, sOutputDataURL, rScript).Wait();
StringBuilder sb = new StringBuilder();
//if web service successully saved the results, the response will start with Success
if (_response.StartsWith("Success"))
{
//return the output file contents in a string list of lines
//must convert container path to full path
string sOutputFullDataURL = string.Concat("https://devtreks1.blob.core.windows.net/", sOutputDataURL);
List <string> lines = new List <string>();
//azure emulator can't process real Azure URL so this won't work
//instead, double check that output url is actually saved
lines = CalculatorHelpers.ReadLines(_params.ExtensionDocToCalcURI, sOutputFullDataURL, out sError);
this.ErrorMessage += sError;
//this results in endless wait-try ReadLinesAsync(sOutputDataURL).ConfigureAwait(false)
//lines = await CalculatorHelpers.ReadLinesAsync(sOutputDataURL);
if (lines == null)
{
this.ErrorMessage += string.Concat(" ", Errors.MakeStandardErrorMsg("DATAURL_BAD"));
return(bHasCalcs);
}
if (lines.Count == 0)
{
this.ErrorMessage += string.Concat(" ", Errors.MakeStandardErrorMsg("DATAURL_BAD"));
return(bHasCalcs);
}
sb = new StringBuilder();
if (_subalgorithm == Calculator1.MATH_SUBTYPES.subalgorithm2.ToString())
{
sb.AppendLine("py results");
}
else
{
sb.AppendLine("r results");
}
//dep var has to be in the R project 1st column
string sLine = string.Concat("first variable: ", _colNames[0]);
string[] line = new List <string>().ToArray();
for (int i = 0; i < lines.Count(); i++)
{
line = lines[i].Split(Constants.CSV_DELIMITERS);
//lineout[1] = CalculatorHelpers.ConvertStringToDouble(line[0]).ToString("N4", CultureInfo.InvariantCulture);
sb.AppendLine(Shared.GetLine(line, false));
}
if (this.MathResult.ToLower().StartsWith("http"))
{
sError = string.Empty;
bool bHasSaved = CalculatorHelpers.SaveTextInURI(
_params.ExtensionDocToCalcURI, sb.ToString(), this.MathResult, out sError);
if (!string.IsNullOrEmpty(sError))
{
this.MathResult += sError;
}
}
else
{
this.MathResult = sb.ToString();
}
bHasCalcs = true;
//last line of string should have the QTM vars
if (line != null)
{
int iPos = 0;
if (line[iPos] != null)
{
this.QTPredicted = CalculatorHelpers.ConvertStringToDouble(line[iPos]);
}
iPos = 1;
if (line[iPos] != null)
{
this.QTL = CalculatorHelpers.ConvertStringToDouble(line[iPos]);
}
iPos = 2;
if (line[iPos] != null)
{
this.QTU = CalculatorHelpers.ConvertStringToDouble(line[iPos]);
}
}
}
else
{
this.ErrorMessage += string.Concat(_response, "The calculations could not be run using the web service.");
}
return(bHasCalcs);
}
public void RunOptimization(
List <TimelinessTimePeriod1> timelinessTimePeriods)
{
InitCollections(timelinessTimePeriods);
if (this.ErrorMessage == string.Empty)
{
try
{
//initial collections of TP.OpComps (with each OpComp holding feasible OpComp.TimelinessOpComps)
random = new Random(0);
// total cost index for problem definition
double[][] problemData = MakeProblemData(timelinessTimePeriods);
//state represents a solution int array where the first index is the feasibleOpComp
//and the second index is the uniqueOpComp
//(uniqueOpComp - feasibleOpComp combos that are not possible must have a zero total cost)
int[] state = RandomState(problemData);
double energy = Energy(state, problemData);
//best state is the least cost vector of 1 unique opcomp and 1 feasible opcomp
int[] bestState = state;
double bestEnergy = energy;
int[] adjState;
double adjEnergy;
int iteration = 0;
//the higher these are, the longer the algorithm runs
//the longer the algo runs the more optimal the solution
int maxIteration = 1000000;
double currTemp = 10000.0;
// cooling rate
double alpha = 0.995;
while (iteration < maxIteration && currTemp > 0.0001)
{
//adjacent state doesn't allow nonfeasible selections (w,t = 0)
adjState = AdjacentState(state, problemData);
adjEnergy = Energy(adjState, problemData);
if (adjEnergy < bestEnergy)
{
bestState = adjState;
bestEnergy = adjEnergy;
}
// [0, 1.0)
double p = random.NextDouble();
if (AcceptanceProb(energy, adjEnergy, currTemp) > p)
{
state = adjState;
energy = adjEnergy;
}
// cool down; annealing schedule
currTemp = currTemp * alpha;
++iteration;
}
//temperature has cooled to (almost) zero at final iteration
MakeBestMachineryCombos(timelinessTimePeriods, bestState, problemData);
}
catch (Exception ex)
{
this.ErrorMessage = string.Concat(Errors.GetMessage("RESOURCESTOCKS_NOSIMULATEDANNEALING"),
ex.ToString());
}
}
}
