private static ScoringOutput GetScores(List <string> scaleNames, List <ItemInformation> itemInformationList, List <string> personNames, List <UserAnswers> answersInput,
                                               CATParameters catParameters)
        {
            List <ScoreDetails>         scores           = new List <ScoreDetails>();
            List <List <QuestionInfo> > questionInfoList = new List <List <QuestionInfo> >();

            foreach (var scaleName in scaleNames)
            {
                List <ItemInformation> itemInfoForScale = itemInformationList.Where(x => x.ScaleName.Equals(scaleName)).ToList();
                IQuestionLoader        questionLoader   = new ExcelQuestionLoader(itemInfoForScale, catParameters.MistakeProbability);
                foreach (var personName in personNames)
                {
                    UserAnswers        personAnswers     = answersInput.Single(x => x.PersonName.Equals(personName));
                    ScaleAnswers       answers           = personAnswers.ScaleAnswers.Single(x => x.ScaleName.Equals(scaleName));
                    IAnswerSheetLoader answerSheetLoader = new ExcelAnswerSheetLoader(answers);

                    LocationEstimator   locationEstimator = new LocationEstimator(questionLoader, answerSheetLoader, catParameters);
                    List <QuestionInfo> output            = locationEstimator.EstimatePersonLocation();
                    questionInfoList.Add(output);

                    ScoreDetails scoreDetails = new ScoreDetails()
                    {
                        PersonName = personName,
                        ScaleName  = scaleName,
                        Score      = (double)output.Last().ThetaEstimate
                    };
                    scores.Add(scoreDetails);
                }
            }

            ScoringOutput scoringOutput = new ScoringOutput()
            {
                FirstPersonQuestionInfo = questionInfoList.First(),
                ScoreDetails            = scores
            };

            return(scoringOutput);
        }
        public void Write(ScoringOutput scoringOutput)
        {
            ExcelWriter.Workbooks excelWorkbooks;
            ExcelWriter.Workbook  myExcelWorkbook;

            object misValue = System.Reflection.Missing.Value;

            _excelApp.Visible = false;
            excelWorkbooks    = _excelApp.Workbooks;
            String fileName = _excelLocationString;

            myExcelWorkbook = excelWorkbooks.Open(fileName, misValue, false, misValue, misValue, misValue, misValue,
                                                  misValue, misValue, misValue, misValue, misValue, misValue, misValue, misValue);

            ExcelWriter.Worksheet outputTabWorksheet             = (ExcelWriter.Worksheet)myExcelWorkbook.Sheets["Output"];
            ExcelWriter.Worksheet firstPersonDetailsTabWorksheet = (ExcelWriter.Worksheet)myExcelWorkbook.Sheets["First Person Detailed Output"];

            ClearWorksheet(outputTabWorksheet);
            ClearWorksheet(firstPersonDetailsTabWorksheet);

            var scoreDetails = scoringOutput.ScoreDetails;

            List <string> scaleNames = scoreDetails.Select(x => x.ScaleName).Distinct().ToList();

            PrintOutputTabHeader(scaleNames, outputTabWorksheet);
            WriteOutputTabPersons(scoreDetails, outputTabWorksheet, scaleNames);

            PrintFirstPersonDetailsHeader(firstPersonDetailsTabWorksheet);
            PrintFirstPersonDetailsResults(firstPersonDetailsTabWorksheet, scoringOutput.FirstPersonQuestionInfo);

            SaveWorksheet(outputTabWorksheet, _excelApp);
            excelWorkbooks.Close();
            _excelApp.Quit();

            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }
        /// <summary>
        /// Saves the numeric prediction result to MLPrediction entity.
        /// </summary>
        /// <param name="modelId">The model identifier.</param>
        /// <param name="modelInstanceId">The model instance identifier.</param>
        /// <param name="entityId">The entity identifier.</param>
        /// <param name="result">Result, returned by ML service.</param>
        public virtual void SavePrediction(Guid modelId, Guid modelInstanceId, Guid entityId, ScoringOutput result)
        {
            var query = new Insert(_userConnection)
                        .Into("MLPrediction")
                        .Set("Id", Column.Parameter(Guid.NewGuid()))
                        .Set("CreatedOn", new QueryParameter(DateTime.UtcNow))
                        .Set("ModifiedOn", new QueryParameter(DateTime.UtcNow))
                        .Set("ModelId", new QueryParameter(modelId))
                        .Set("ModelInstanceUId", new QueryParameter(modelInstanceId))
                        .Set("Key", new QueryParameter(entityId))
                        .Set("Probability", new QueryParameter(result.Score));

            if (!result.Contributions.IsNullOrEmpty())
            {
                string contributions = Json.Serialize(result.Contributions);
                query = query
                        .Set("FeatureContributions", new QueryParameter(contributions))
                        .Set("Bias", new QueryParameter(result.Bias));
            }
            query.Execute();
        }
        private static void WriteOutput(string excelLocationString, ScoringOutput scores, Application app)
        {
            ExcelOutputWriter writer = new ExcelOutputWriter(excelLocationString, app);

            writer.Write(scores);
        }