Beispiel #1
0
        public static double CalculateScore(KidsUser user, bool CalcRemain, out List<scoreListItem> DailyscoreList, out List<scoreListItem> MonthlyscoreList)
        {
            DailyscoreList = new List<scoreListItem>();
            MonthlyscoreList = new List<scoreListItem>();
            double CalculatedScore = 0.0;

            if (user != null)
            {
                var scoreTypes = Score_DataProvider.GetScoresTypes();
                var userScore = user.Kids_Scores.ToList();

                foreach (ScoreType scoreType in scoreTypes)
                {
                    var specialtype = scoreType.ScoreEnName.ToEnumByName<SpecialScoreType>();
                    if (specialtype.HasValue && IsSpecialScoreType(scoreType))
                    {
                        if (!CalcRemain && specialtype.Value == SpecialScoreType.ACCREMAIN)
                            continue;

                        CalculatedScore += CalculateSpecialScore(user, scoreType, ref DailyscoreList, ref MonthlyscoreList);
                    }
                    else
                    {
                        CalculatedScore = !scoreType.IsRangeBaseScore ?
                            CalculateScalerScore(ref DailyscoreList, ref MonthlyscoreList, userScore, scoreType, CalculatedScore) :
                            CalculateVectorScore(ref DailyscoreList, ref MonthlyscoreList, scoreType, userScore, CalculatedScore);
                    }
                }

            }
            return CalculatedScore;
        }
Beispiel #2
0
 public static void AddScore(KidsUser user, ScoreType scoreType, Double Value)
 {
     Kids_Scores kscore = new Kids_Scores
     {
         KidsUser = user,
         ScoreTypeId = scoreType.Id,
         Value = Value,
         CreateDateTime = DateTime.Now
     };
     Score_DataProvider.SaveScore(kscore);
 }
Beispiel #3
0
        private static double CalculateSpecialScore(KidsUser user, ScoreType scoreType, ref List<scoreListItem> DailyscoreList,
                                                    ref List<scoreListItem> MonthlyscoreList)
        {
            switch (scoreType.ScoreEnName.ToEnumByName<SpecialScoreType>())
            {
                case SpecialScoreType.REGISTRATION:
                    #region
                    {
                        if (user.CurrentStatus == (int)KidsUserStatus.RegisterWithoutConfirmation)
                            return 0;

                        DailyscoreList.Add(new scoreListItem
                            {
                                Date = PersianDateTime.MiladiToPersian(user.CreateDateTime).ToString(),
                                scoreType = scoreType,
                                Sum_Filtered = scoreType.CoefficentValue,
                                Sum_NotFiltered = scoreType.CoefficentValue
                            });

                        MonthlyscoreList.Add(new scoreListItem
                        {
                            Date = PersianDateTime.MiladiToPersian(user.CreateDateTime).ToString(),
                            scoreType = scoreType,
                            Sum_Filtered = scoreType.CoefficentValue,
                            Sum_NotFiltered = scoreType.CoefficentValue
                        });
                        return scoreType.CoefficentValue;
                    }
                    #endregion

                case SpecialScoreType.ADDACCOUNT:
                    #region

                    {
                        if (user != null && !string.IsNullOrWhiteSpace(user.ChildAccNo))
                        {
                            DailyscoreList.Add(new scoreListItem
                                {
                                    Date = PersianDateTime.MiladiToPersian(user.LastUpdateDateTime.Value).ToString(),
                                    scoreType = scoreType,
                                    Sum_Filtered = scoreType.CoefficentValue,
                                    Sum_NotFiltered = scoreType.CoefficentValue
                                });

                            MonthlyscoreList.Add(new scoreListItem
                            {
                                Date = PersianDateTime.MiladiToPersian(user.LastUpdateDateTime.Value).ToString(),
                                scoreType = scoreType,
                                Sum_Filtered = scoreType.CoefficentValue,
                                Sum_NotFiltered = scoreType.CoefficentValue
                            });

                            return scoreType.CoefficentValue;
                        }
                        return 0;
                    }
                    #endregion

                case SpecialScoreType.ACCREMAIN:
                    #region
                    {
                        try
                        {
                            if (user != null && !string.IsNullOrWhiteSpace(user.ChildAccNo))
                            {
                                string tx_date;
                                long Remain = BMICustomer_DataProvider.GetAccRemain(user, out tx_date);
                                var RemainScore = Remain.ToString().ToDouble() * scoreType.CoefficentValue;
                                DailyscoreList.Add(new scoreListItem
                                                  {
                                                      Date = tx_date,
                                                      scoreType = scoreType,
                                                      Sum_NotFiltered = RemainScore,
                                                      Sum_Filtered = Math.Min(RemainScore, scoreType.MaxPerMonth)
                                                  });

                                MonthlyscoreList.Add(new scoreListItem
                                {
                                    Date = tx_date,
                                    scoreType = scoreType,
                                    Sum_NotFiltered = RemainScore,
                                    Sum_Filtered = Math.Min(RemainScore, scoreType.MaxPerMonth)
                                });
                                return Math.Min(RemainScore, scoreType.MaxPerMonth);

                            }
                            return 0;
                        }
                        catch
                        {
                            return 0;
                        }
                    }
                    #endregion

                case SpecialScoreType.POLL:
                    #region
                    {
                        int cnt = user.PollUserResponses.Count(poll => poll.PollQuestion.HasScore);
                        var pollscore = cnt * scoreType.CoefficentValue;


                        var Monthly_PollGroup = user.PollUserResponses.Where(poll => poll.PollQuestion.HasScore)
                                                    .GroupBy(o => PersianDateTime.MiladiToPersian(o.CreateDateTime).ToString().Substring(0, 6)).ToList();

                        var Daily_PollGroup = user.PollUserResponses.Where(poll => poll.PollQuestion.HasScore)
                                                    .GroupBy(o => PersianDateTime.MiladiToPersian(o.CreateDateTime).ToString()).ToList();

                        foreach (var d in Daily_PollGroup)
                        {
                            DailyscoreList.Add(new scoreListItem
                            {
                                Date = d.Key,
                                scoreType = scoreType,
                                Sum_NotFiltered = d.Count() * scoreType.CoefficentValue,
                                Sum_Filtered = d.Count() * scoreType.CoefficentValue
                            });
                        }

                        foreach (var m in Monthly_PollGroup)
                        {
                            MonthlyscoreList.Add(new scoreListItem
                            {
                                Date = m.Key,
                                scoreType = scoreType,
                                Sum_NotFiltered = m.Count() * scoreType.CoefficentValue,
                                Sum_Filtered = Math.Min(m.Count() * scoreType.CoefficentValue, scoreType.MaxPerMonth)
                            });
                        }

                        return Math.Min(pollscore, scoreType.MaxPerMonth);
                    }
                    #endregion

                default:
                    throw new NotImplementedException(scoreType.ScoreEnName);
            }
        }