TEAMModelOS/TEAMModelOS.Service/Evaluation/Implements/ExamInfoService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TEAMModelOS.Model.Evaluation.Dtos.Own;
using TEAMModelOS.Model.Evaluation.Models.CosmosModels;
using TEAMModelOS.Model.EvaluaTion.Dtos;
using TEAMModelOS.Model.EvaluaTion.Models;
using TEAMModelOS.SDK.Module.AzureCosmosDB.Interfaces;
using TEAMModelOS.Service.Core.Implements;
using TEAMModelOS.Service.EvaluaTion.Interfaces;

namespace TEAMModelOS.Service.EvaluaTion.Implements
{
    public class ExamInfoService : BaseService, IExamInfoService
    {

        public IAzureCosmosDBRepository _cosmosrepository;
        public ExamInfoService(IAzureCosmosDBRepository cosmosDBRepository)
        {
            _cosmosrepository = cosmosDBRepository;
        }


        public async Task<List<MemberAnswer>> SaveOrUpdate(List<MemberAnswer> answers, string lang)
        {

            List<AnswerInfo> answerInfos = new List<AnswerInfo>();
            if (null != answers)
            {
                answers.ForEach(e =>
                {
                    answerInfos.Add(new AnswerInfo()
                    {
                        RowKey = Guid.NewGuid().ToString(),
                        PartitionKey = lang,
                        StudentId = e.StudentId,
                        ExNO = e.ExNO,
                        Index = e.Itemindex,
                        Selection = e.Selection,
                        Point = e.Point
                        


                    });
                });
            }
            await SaveOrUpdateAll(answerInfos);
            return answers;
        }

        public async Task<List<ExerciseInfo>> SaveOrUpdateAsync(List<ExerciseInfo> exercises, string lang)
        {

            List<ExamInfo> exams = new List<ExamInfo>();
            if (null != exercises)
            {
                exercises.ForEach(e =>
                {
                    exams.Add(new ExamInfo()
                    {
                        RowKey = Guid.NewGuid().ToString(),
                        PartitionKey = lang,
                        ExName = e.Ex_name,
                        ExTime = e.Ex_time,
                        CouseName = e.Course_name,
                        SchoolName = e.SchoolName,
                        GradeName = e.GradeName,
                        AcademicYear = int.Parse(e.AcademicYear),
                        SOrder = int.Parse(e.SOrder),
                        CouseNO = e.Course_no,
                        ClassCode = e.Class_code,
                        ClassName = e.Class_name,
                        QNumber = e.QNumber,
                        StuCount = e.Stucount,
                        EndTime = e.End_time,
                        ClassAvgScore = e.AvgScore

                    });
                });
            }
            await SaveOrUpdateAll(exams);
            return exercises;
            //throw new NotImplementedException();
        }

        public Task<List<MemberAnswer>> SaveToCosmosAnswer(List<MemberAnswer> items)
        {
            throw new NotImplementedException();
        }

        public async Task<List<ExerciseInfo>> SaveToCosmosExamAsync(List<ExerciseInfo> exercises, List<MemberAnswer> members)
        {
            List<Exam> exams = new List<Exam>();
            List<Answer> answers = new List<Answer>();
            List<CouseExam> couseExams = new List<CouseExam>();
            List<Exam> objs = new List<Exam>();
            List<CouseExam> couseObjs = new List<CouseExam>();
            if (null != exercises)
            {
                members.ForEach(m => {
                    answers.Add(new Answer
                    {
                        Id = Guid.NewGuid().ToString(),
                        ExNO = m.ExNO,
                        Index = m.Itemindex,
                        Point = float.Parse(m.Point.ToString()),
                        Detail = m.Selection,
                        StudentId = m.StudentId
                    });
                });
                exercises.ForEach(e =>
                {
                    string ExamNumber = e.Ex_name.Replace(" ", "").Split("_")[1];
                    answers.ForEach(a =>
                    {
                        if (e.ExNO.Equals(a.ExNO) ) {
                            //a.ExNO = e.ExNO;
                            //a.Number = ExamNumber;
                            a.GradeCode = e.GradeName;
                            a.SchoolCode = e.SchoolName;
                            a.ClassCode = e.Class_code;
                            a.CourseCode = e.Course_name;
                            a.ExamName = e.Ex_name.Replace(" ", "").Split("-")[0] + "-" + e.Ex_name.Replace(" ", "").Split("-")[1];
                        }
                    });                   
                    exams.Add(new Exam()
                    {
                        Id = Guid.NewGuid().ToString(),
                        Number = ExamNumber,
                        Name = e.Ex_name.Replace(" ","").Split("-")[0]+ "-"+e.Ex_name.Replace(" ", "").Split("-")[1],
                        Time = e.Ex_time
                    });

                    couseExams.Add(new CouseExam()
                    {
                        Id = Guid.NewGuid().ToString(),
                        //Number = ExamNumber,
                        ExNO = e.ExNO,
                        ExName = e.Ex_name.Replace(" ", "").Split("-")[0] + "-" + e.Ex_name.Replace(" ", "").Split("-")[1],
                        ExTime = e.Ex_time,
                        AcademicYear = int.Parse(e.AcademicYear),
                        SOrder = int.Parse(e.SOrder),
                        Subject = e.Course_name,
                        SchoolName = e.SchoolName

                    });
                });

                

                objs = exams.Where((x, i) => exams.FindIndex(z => z.Name == x.Name) == i).ToList();
                couseObjs = couseExams.Where((x, i) => couseExams.FindIndex(z => z.ExName == x.ExName && z.Subject == x.Subject) == i).ToList();
                objs.ForEach(f =>
                {
                    couseObjs.ForEach(g => {
                        if (f.Name.Equals(g.ExName)) {
                            g.Number = f.Number;
                        }

                    });
                });                
                couseObjs.ForEach(g => {
                    answers.ForEach(x =>
                    {
                        if (g.Subject.Equals(x.CourseCode) && g.SchoolName.Equals(x.SchoolCode)
                        && g.ExName.Equals(x.ExamName))
                        {
                            x.Number = g.Number;
                            x.ExNO = g.ExNO;
                        }
                    });
                });

            }
            await _cosmosrepository.SaveAll(objs);
            await _cosmosrepository.SaveAll(couseObjs);
            await _cosmosrepository.SaveAll(answers);

            return exercises;
        }
        public async Task<List<ExerciseInfo>> SaveToCosmosExam(List<ExerciseInfo> exercises, List<MemberAnswer> members)
        {
            List<Exams> exams = new List<Exams>();
            List<AnswerDetail> answerDetail = new List<AnswerDetail>();
            List<Answers> answers = new List<Answers>();
            List<Exams> objs = new List<Exams>();


            foreach (IGrouping<string, MemberAnswer> group in members.GroupBy(c => c.ExNO +"---"+ c.StudentId)) {
                string[] keys = group.Key.Split("---");
                
                var list= group.ToList();
                Answers answer = new Answers
                {
                    Id = Guid.NewGuid().ToString(),
                    ExNO = keys[0],
                    StudentId = keys[1]
                };
                foreach (var ls in list) {
                    answer.Detail.Add(new AnswerDetail {
                        Index = ls.Itemindex,
                        Point = float.Parse(ls.Point),
                        Detail = ls.Selection

                    });
                }
                answers.Add(answer);

            }
            //List<CouseExam> couseObjs = new List<CouseExam>();
            if (null != exercises) {
                
                exercises.ForEach(e =>
                {
                    exams.Add(new Exams() {
                        Id = Guid.NewGuid().ToString(),                        
                        ExNO = e.Ex_name.Replace(" ", "").Split("_")[1],
                        ExName = e.Ex_name.Replace(" ", "").Split("-")[0] + "-" + e.Ex_name.Replace(" ", "").Split("-")[1],
                        ExTime = e.Ex_time,
                        AcademicYear = int.Parse(e.AcademicYear),
                        SOrder = int.Parse(e.SOrder),
                        Sub = e.Course_name
                    });
                    answers.ForEach(a =>
                    {
                        if (a.ExNO.Equals(e.ExNO))
                        {
                            a.ExNO = e.Ex_name.Replace(" ", "").Split("_")[1];
                            a.GradeCode = e.GradeName;
                            a.SchoolCode = e.SchoolName;
                            a.ClassCode = e.Class_code;
                            a.CourseCode = e.Course_name;
                        }
                    });
                    
                    objs = exams.Where((x, i) => exams.FindIndex(z => z.ExName == x.ExName && z.Sub
                    == x.Sub) == i).ToList();
                                  
                });
            }
            await _cosmosrepository.SaveAll(objs);
            await _cosmosrepository.SaveAll(answers);
            return exercises;
        }

        public async Task<SimpleExam> SaveToCosmos(SimpleExam simple)
        {
            await _cosmosrepository.Save(simple);
            return simple;
            //throw new NotImplementedException();
        }

        public async Task<List<StuInfo>> SaveListToCosmos(List<StuInfo> stu)
        {
            await _cosmosrepository.SaveAll(stu);
            return stu;
            //throw new NotImplementedException();
        }
    }

}