//define the actions to take when the event is raised
        public void AddCalculations(object sender, CustomEventArgs e)
        {
            //pass a byref xelement from the publisher's data
            XElement statElement       = null;
            XElement linkedViewElement = null;

            if (e.CurrentElement != null)
            {
                statElement = new XElement(e.CurrentElement);
            }
            if (e.LinkedViewElement != null)
            {
                linkedViewElement = new XElement(e.LinkedViewElement);
            }
            MN1CalculatorHelper.CALCULATOR_TYPES eCalculatorType
                = MN1CalculatorHelper.GetCalculatorType(
                      this.GCCalculatorParams.CalculatorType);
            //run normally and save the same statelement and linkedviewelement
            e.HasCalculations = RunMN1Analysis(
                ref statElement, ref linkedViewElement);
            if (e.HasCalculations)
            {
                //pass the new statelement back to the publisher
                //by setting the CalculatedElement property of CustomEventArgs
                if (statElement != null)
                {
                    e.CurrentElement = new XElement(statElement);
                }
                if (linkedViewElement != null)
                {
                    e.LinkedViewElement = new XElement(linkedViewElement);
                }
            }
        }
예제 #2
0
 private static void CheckForLastStepCalculator(
     CalculatorParameters mn1CalcParams,
     ContractHelpers.EXTENSION_STEPS stepNumber,
     ExtensionContentURI extDocToCalcURI)
 {
     MN1CalculatorHelper.CALCULATOR_TYPES eCalculatorType
         = MN1CalculatorHelper.GetCalculatorType(
               mn1CalcParams.CalculatorType);
     //other projects have code for handling different
     //numbers of steps in calculators
 }
예제 #3
0
        //define the actions to take when the event is raised
        public void AddCalculations(object sender, CustomEventArgs e)
        {
            //pass a byref xelement from the publisher's data
            XElement statElement       = null;
            XElement linkedViewElement = null;

            if (e.CurrentElement != null)
            {
                statElement = new XElement(e.CurrentElement);
            }
            if (e.LinkedViewElement != null)
            {
                linkedViewElement = new XElement(e.LinkedViewElement);
            }
            //run the stats and add them to statelement
            MN1CalculatorHelper.CALCULATOR_TYPES eCalculatorType
                = MN1CalculatorHelper.GetCalculatorType(
                      this.GCCalculatorParams.CalculatorType);
            //run the stats and add them to statelement
            if (eCalculatorType == MN1CalculatorHelper.CALCULATOR_TYPES.foodnutSR01 ||
                eCalculatorType == MN1CalculatorHelper.CALCULATOR_TYPES.foodnutSR02)
            {
                e.HasCalculations = RunMN1Calculation(eCalculatorType,
                                                      statElement, linkedViewElement);
            }
            else
            {
                //run normally and save the same statelement and linkedviewelement
                e.HasCalculations = RunMN1Analysis(
                    statElement, linkedViewElement);
                //if (!this.HasTotals)
                //{
                //    //run normally and save the same statelement and linkedviewelement
                //    e.HasCalculations = RunMN1Analysis(
                //        statElement, linkedViewElement);
                //}
            }
            if (e.HasCalculations)
            {
                //pass the new statelement back to the publisher
                //by setting the CalculatedElement property of CustomEventArgs
                if (statElement != null)
                {
                    e.CurrentElement = new XElement(statElement);
                }
                if (linkedViewElement != null)
                {
                    e.LinkedViewElement = new XElement(linkedViewElement);
                }
            }
        }
예제 #4
0
        //define the actions to take when the event is raised
        public void AddDevPackCalculations(object sender, CustomEventArgs e)
        {
            bool bHasCalculations = false;
            //e.CalculatorParams = current devpack or devpackpart being processed
            //the file paths identify the document to run calcs on and the
            //uripattern identifies the node holding the linkedviews
            //note that e.CalcParams.ExtensionDoctoCalcURI.Resources[0] holds
            //parent contenturi used to start the extension
            //(with original doctocalc file that is used when the linkedview is needed)
            MN1CalculatorHelper fnCalculatorHelper
                = new MN1CalculatorHelper(e.CalculatorParams);

            //run the calculations
            //bHasCalculations = fnCalculatorHelper
            //    .RunCalculations();
            //pass the bool back to the publisher
            //by setting the HasCalculations property of CustomEventArgs
            e.HasCalculations = bHasCalculations;
        }
예제 #5
0
        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 MN1CalcParams
                = CalculatorHelpers.SetCalculatorParameters(
                      extDocToCalcURI, extCalcDocURI, stepNumber, urisToAnalyze,
                      updates);
            MN1CalculatorHelper mn1BudgetHelper
                = new MN1CalculatorHelper(MN1CalcParams);

            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 (MN1CalcParams != null)
                {
                    //set constants for this step
                    bHasCalculation
                        = await MN1CalculatorHelper.SetConstants(MN1CalcParams);
                }
                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(MN1CalcParams, stepNumber, updates);

                if (MN1CalcParams != null)
                {
                    //run the calculations
                    bHasCalculation = await mn1BudgetHelper.RunMN1CalculatorCalculations();

                    extDocToCalcURI.ErrorMessage  = MN1CalcParams.ErrorMessage;
                    extDocToCalcURI.ErrorMessage += MN1CalcParams.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(MN1CalcParams,
                                                   eStepNumber, extDocToCalcURI);
                        //replace the old calculator with the new one
                        //and save the new calculations document
                        bHasCalculation
                            = await CalculatorHelpers.SaveNewCalculationsDocument(MN1CalcParams);
                    }
                    else
                    {
                        bHasCalculation = false;
                    }
                }
                extDocToCalcURI.URIDataManager.NeedsFullView    = true;
                extDocToCalcURI.URIDataManager.NeedsSummaryView = false;
                break;

            case ContractHelpers.EXTENSION_STEPS.stepfour:
                extDocToCalcURI.URIDataManager.NeedsFullView    = false;
                extDocToCalcURI.URIDataManager.NeedsSummaryView = true;
                extCalcDocURI.URIFileExtensionType = CalculatorHelpers.GetAttribute(MN1CalcParams.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 += MN1CalcParams.ErrorMessage;
            return(bHasCalculation);
        }