コード例 #1
0
        public static Guid 随机生成试卷(取题条件 getProblemCondition, out int 试题充足情况)
        {
            试题充足情况 = 0;
            LoveKaoExamEntities db = new LoveKaoExamEntities();
            if (getProblemCondition.取题题型及数量集合.Count > 15)
            {
                throw new Exception("试卷题型不能超过15个!");
            }
            foreach (取题题型及数量 typeNum in getProblemCondition.取题题型及数量集合)
            {
                if (typeNum.数量 > 200)
                {
                    throw new Exception("每个题型下的题目不能超过200道!");
                }
            }
            试卷外部信息 outside = new 试卷外部信息();
            outside.ID = Guid.NewGuid();
            outside.爱考网ID = outside.ID;
            outside.创建人ID = 用户信息.CurrentUser.用户ID;
            outside.名称 = getProblemCondition.试卷名称;
            outside.说明 = "";
            outside.分类列表 = new List<string>();
            //给试卷内容赋值
            试卷内容 test = new 试卷内容();
            test.ID = Guid.NewGuid();
            test.名称 = getProblemCondition.试卷名称;
            test.说明 = "";
            test.提交人ID = outside.创建人ID;
            test.提交备注 = "";
            test.试卷外部信息ID = outside.ID;
            if (getProblemCondition.网站分类集合 == null || getProblemCondition.网站分类集合 == "")
            {
                throw new Exception("您还没选择分类,请先选择!");
            }
            if (getProblemCondition.网站分类集合 != null && getProblemCondition.网站分类集合 != "")
            {
                string[] sortList = getProblemCondition.网站分类集合.Split(",".ToCharArray());
                if (sortList.Length > 10)
                {
                    throw new Exception("分类选择不能超过10个!");
                }
                foreach (string sortName in sortList)
                {
                    outside.分类列表.Add(sortName);
                }
            }
            test.试卷中大题集合 = new List<试卷中大题>();
            decimal totalScore = 0;
            //遍历题型数量,并赋值
            for (int i = 0; i < getProblemCondition.取题题型及数量集合.Count; i++)
            {
                getProblemCondition.取题题型及数量集合[0] = getProblemCondition.取题题型及数量集合[i];
                List<试题外部信息表> listOutside = 试题外部信息.判断取题条件(getProblemCondition).ToList();
                totalScore += getProblemCondition.取题题型及数量集合[i].每小题分值 * getProblemCondition.取题题型及数量集合[i].数量;
                试卷中大题 type = new 试卷中大题();
                type.ID = Guid.NewGuid();
                type.名称 = getProblemCondition.取题题型及数量集合[i].题型名称;
                type.说明 = "";
                //随机取到的试题内容ID集合
                if (getProblemCondition.取题题型及数量集合[i].数量 != 0)
                {
                    List<Guid> listProblemId = 试题外部信息.随机取题(getProblemCondition.取题题型及数量集合[i].题型Enum,
                        getProblemCondition.取题题型及数量集合[i].数量, listOutside, 用户信息.CurrentUser.用户ID);
                    if (listProblemId.Count < getProblemCondition.取题题型及数量集合[i].数量)
                    {
                        试题充足情况 = 2;
                    }

                    type.试卷大题中试题集合 = new List<试卷大题中试题>();
                    //遍历题目数量,并赋值
                    for (int j = 0; j < listProblemId.Count; j++)
                    {

                        试卷大题中试题 testProblem = new 试卷大题中试题();
                        testProblem.ID = Guid.NewGuid();
                        testProblem.试题内容ID = listProblemId[j];
                        testProblem.每小题分值 = getProblemCondition.取题题型及数量集合[i].每小题分值;
                        testProblem.顺序 = Convert.ToByte(j);
                        type.试卷大题中试题集合.Add(testProblem);
                    }
                    //是复合题和多题干共选项题时给子集赋值
                    if (getProblemCondition.取题题型及数量集合[i].题型Enum > 39 && getProblemCondition.取题题型及数量集合[i].题型Enum < 50 ||
                        getProblemCondition.取题题型及数量集合[i].题型Enum == 80)
                    {
                        List<试题内容表> listSubContent = db.试题内容表.Where(a => listProblemId.Contains(a.父试题内容ID.Value)).ToList();
                        var groupSubContent = listSubContent.GroupBy(a => a.父试题内容ID).ToList();
                        foreach (试卷大题中试题 testProblem in type.试卷大题中试题集合)
                        {
                            testProblem.子小题集合 = new List<试卷大题中试题>();
                            var subContent = groupSubContent.Where(a => a.Key == testProblem.试题内容ID).First();
                            foreach (var sub in subContent)
                            {
                                试卷大题中试题 subTestProblem = new 试卷大题中试题();
                                subTestProblem.ID = Guid.NewGuid();
                                subTestProblem.每小题分值 = getProblemCondition.取题题型及数量集合[i].每小题分值 / subContent.Count();
                                subTestProblem.试题内容ID = sub.ID;
                                testProblem.子小题集合.Add(subTestProblem);
                            }
                        }
                    }
                }
                test.试卷中大题集合.Add(type);
            }
            test.总分 = Convert.ToInt32(totalScore);
            outside.当前试卷内容 = test;
            outside.试卷内容ID = test.ID;
            outside.总分 = Convert.ToInt32(totalScore);
            //加入缓存
            MemoryCache.Default.Add("" + outside.ID + "", outside, cacheRandomTest);
            if (试题充足情况 != 2)
            {
                试题充足情况 = 1;
            }
            return outside.ID;
        }
コード例 #2
0
 /// <summary>
 /// 因有无限循环,故无法用Mapper函数转化类
 /// </summary>
 private static 试卷大题中试题 把试卷大题中试题WCF转化成试卷大题中试题(LoveKaoServiceReference.试卷大题中试题WCF testProblemWCF)
 {
     试卷大题中试题 testProblem = new 试卷大题中试题();
     testProblem.ID = testProblemWCF.ID;
     testProblem.每小题分值 = testProblemWCF.每小题分值;
     testProblem.试卷中大题ID = testProblemWCF.试卷中大题ID;
     testProblem.试题内容ID = testProblemWCF.试题内容ID;
     testProblem.试题内容Json = testProblemWCF.试题内容Json;
     testProblem.顺序 = testProblemWCF.顺序;
     return testProblem;
 }
コード例 #3
0
 /// <summary>
 /// 因有无限循环,故无法用Mapper函数转化类
 /// </summary>
 private static LoveKaoServiceReference.试卷大题中试题 把试卷大题中试题转化成试卷大题中试题WCF(试卷大题中试题 testProblem)
 {
     LoveKaoServiceReference.试卷大题中试题 testProblemWCF = new LoveKaoServiceReference.试卷大题中试题();
     testProblemWCF.ID = testProblem.ID;
     testProblemWCF.每小题分值 = testProblem.每小题分值;
     testProblemWCF.试卷中大题ID = testProblem.试卷中大题ID;
     testProblemWCF.试题内容ID = testProblem.试题内容ID;
     testProblemWCF.试题内容Json = testProblem.试题内容Json;
     testProblemWCF.顺序 = testProblem.顺序;
     return testProblemWCF;
 }
コード例 #4
0
        public static string getMarkItem(试卷大题中试题 试题, 序号对象类 序号对象, int 子小题序号, bool 是否为小题, bool 是否显示答案)
        {
            string htmlHead = "", htmlCont = "", htmlFoot = "";
            bool 是否为父级 = false;
            int 小题型Enum = 试题内容.得到试题的小题型(试题.试题内容Json);
            switch (小题型Enum)
            {
                case 11:
                    {
                        试题.试题内容 = 单选题.把Json转化成试题内容(试题.试题内容Json);
                        单选题 T11 = (单选题)试题.试题内容;
                        htmlHead += ViewLibHeader.getNormal(T11.题干HTML, T11.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
                        htmlCont += ViewLibContent.getT11(T11.选项列表);
                        htmlFoot += ViewLibKeyResolu.getT11(T11, 是否显示答案);
                    }
                    break;
                case 12:
                    {
                        试题.试题内容 = 多选题.把Json转化成试题内容(试题.试题内容Json);
                        多选题 T12 = (多选题)试题.试题内容;
                        htmlHead += ViewLibHeader.getNormal(T12.题干HTML, T12.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
                        htmlCont += ViewLibContent.getT12(T12.选项列表);
                        htmlFoot += ViewLibKeyResolu.getT12(T12, 是否显示答案);
                    }
                    break;
                case 13:
                    {
                        试题.试题内容 = 填空题.把Json转化成试题内容(试题.试题内容Json);
                        填空题 T13 = (填空题)试题.试题内容;
                        htmlHead += ViewLibHeader.getT13(T13.题干HTML, T13.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
                        htmlFoot += ViewLibKeyResolu.getT13(T13, 是否显示答案);
                    }
                    break;
                case 14:
                    {
                        试题.试题内容 = 选词填空.把Json转化成试题内容(试题.试题内容Json);
                        选词填空 T14 = (选词填空)试题.试题内容;
                        htmlHead += ViewLibHeader.getT14(T14.题干HTML, T14.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
                        htmlCont += ViewLibContent.getT14(T14.选项组.选项集合);
                        htmlFoot += ViewLibKeyResolu.getT14(T14, 是否显示答案);
                    }
                    break;

                case 15:
                    {
                        试题.试题内容 = 完形填空.把Json转化成试题内容(试题.试题内容Json);
                        完形填空 T15 = (完形填空)试题.试题内容;
                        htmlHead += ViewLibHeader.getT15(T15.题干HTML, T15.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
                        htmlCont += ViewLibContent.getT15(T15.单选空格集合);
                        htmlFoot += ViewLibKeyResolu.getT15(T15, 是否显示答案);
                    }
                    break;

                case 20:
                    {
                        试题.试题内容 = 判断题.把Json转化成试题内容(试题.试题内容Json);
                        判断题 T20 = (判断题)试题.试题内容;
                        htmlHead += ViewLibHeader.getNormal(T20.题干HTML, T20.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
                        htmlCont += ViewLibContent.getT20();
                        htmlFoot += ViewLibKeyResolu.getT20(T20, 是否显示答案);
                    }
                    break;

                case 30:
                    {
                        试题.试题内容 = 连线题.把Json转化成试题内容(试题.试题内容Json);
                        连线题 T30 = (连线题)试题.试题内容;
                        htmlHead += ViewLibHeader.getNormal(T30.题干HTML, T30.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
                        htmlCont += ViewLibContent.getT30(T30);
                        htmlFoot += ViewLibKeyResolu.getT30(T30, 是否显示答案);
                    }
                    break;

                case 40:
                case 41:
                case 42:
                case 43:
                case 44:
                case 45:
                case 46:
                case 47:
                    {
                        是否为父级 = true;
                        试题.试题内容 = 复合题.把Json转化成试题内容(试题.试题内容Json);
                        复合题 T40 = (复合题)试题.试题内容;
                        htmlHead += ViewLibHeader.getNormal(T40.题干HTML, T40.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, true, 是否为小题);
                        htmlCont += ViewLibContent.getT40(试题.子小题集合, 序号对象, 是否显示答案);
                        htmlFoot += ViewLibKeyResolu.getT40(T40, 是否显示答案);
                    }
                    break;

                case 60:
                case 61:
                case 62:
                case 63:
                case 64:
                case 65:
                case 66:
                case 67:
                case 68:
                case 69:
                    {
                        试题.试题内容 = 问答题.把Json转化成试题内容(试题.试题内容Json);
                        问答题 T60 = (问答题)试题.试题内容;
                        htmlHead += ViewLibHeader.getNormal(T60.题干HTML, T60.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, false, 是否为小题);
                        htmlFoot += ViewLibKeyResolu.getT60(T60, 是否显示答案);
                    }
                    break;

                case 80:
                    {
                        是否为父级 = true;
                        试题.试题内容 = 多题干共选项题.把Json转化成试题内容(试题.试题内容Json);
                        多题干共选项题 T80 = (多题干共选项题)试题.试题内容;
                        htmlHead += ViewLibHeader.getNormal(T80.题干HTML, T80.试题外部信息ID, 试题.每小题分值, 序号对象, 子小题序号, true, 是否为小题);
                        htmlCont += ViewLibContent.getT80(T80, 试题.子小题集合, 序号对象, 是否显示答案);
                        htmlFoot += ViewLibKeyResolu.getT40(T80, 是否显示答案);
                    }
                    break;
            }

            return getItemHtml(htmlHead, htmlCont, htmlFoot, 是否为父级);
        }