/// <summary>
/// 删除网课及对应的关系表
/// </summary>
/// <param name="Model"></param>
/// <param name="System_Station_ID"></param>
/// <returns></returns>
public bool DeleteCourse(CampusModel Model, int System_Station_ID)
{
SqlMapper.BeginTransaction();
try
{
W_Course model = Orm.Single <W_Course>(x => x.System_Station_ID == System_Station_ID && x.ID == Model.ID);
if (model == null)
{
throw new ApiException("您要操作的数据不存在");
}
if (model.Valid == 1)
{
throw new ApiException("请先禁用，再执行删除操作");
}
int count = SqlMapper.QueryForObject <int>("GetCourseOrderCount", new { ID = Model.ID });
if (count > 0)
{
throw new ApiException("该课程已被网校学生购买无法删除！");
}
Orm.Delete <W_Course>(x => x.ID == Model.ID && x.System_Station_ID == System_Station_ID);
Orm.Delete <W_Course_Chapters>(x => x.Course_ID == Model.ID && x.System_Station_ID == System_Station_ID);
int isDelete = SqlMapper.QueryForObject <int>("DeleteCourse", new { ID = Model.ID, System_Station_ID = System_Station_ID });
Orm.Delete <W_Course_Unit>(x => x.Course_ID == Model.ID && x.System_Station_ID == System_Station_ID);
Orm.Delete <W_DataInfo>(x => x.BusID == Model.ID && x.System_Station_ID == System_Station_ID);
SqlMapper.CommitTransaction();
return(true);
}
catch (Exception ex)
{
SqlMapper.RollBackTransaction();
throw ex;
}
}
/// <summary>
/// 自动组卷
/// </summary>
/// <param name="examPaperId"></param>
/// <returns></returns>
public bool CombinationExamPaper(int examPaperId)
{
W_ExamPaper paper = Orm.Single <W_ExamPaper>(x => x.ID == examPaperId);
if (paper == null)
{
throw new ApiException("试卷不存在或者已删除");
}
//查出试卷所有题型
List <W_ExamPaperDetail> paperDetails = Orm.Select <W_ExamPaperDetail>(x => x.ExamPaper_ID == examPaperId).ToList();
if (paperDetails.Sum(x => x.Sorce * x.Num) < paper.PassScore)
{
throw new ApiException("试卷及格分数大于所有试卷题型总分，不符合大自然规律，请确保试卷题型总分大于及格分数再组卷");
}
//根据试卷题库ID查出题目
List <W_Question> questions = Orm.Select <W_Question>(x => x.QuestionStore_ID == paper.QuestionStore_ID).ToList();
SqlMapper.BeginTransaction();
try
{
//删除原先已组好的试题
Orm.Delete <W_ExamPaperDetail_Detail>(x => x.ExamPaper_ID == paper.ID);
//依据试卷题型的题目类型与题目数量组成试卷
foreach (W_ExamPaperDetail pd in paperDetails)
{
List <W_Question> tempList;
if (pd.QuestionType_ID != 7)
{
tempList = questions.Where(x => x.QuestionType_ID == pd.QuestionType_ID && x.QuestionData_ID == 0).OrderBy(x => Guid.NewGuid()).Take(pd.Num).ToList();
}
else//组合题
{
tempList = questions.Where(x => x.QuestionData_ID > 0).OrderBy(x => x.QuestionData_ID).Take(pd.Num).ToList();
}
if (tempList.Count < pd.Num)
{
throw new ApiException("组卷失败：" + pd.QuestionType_Name + "题目不够");
}
foreach (W_Question question in tempList)
{
Orm.Insert <W_ExamPaperDetail_Detail>(new W_ExamPaperDetail_Detail()
{
ExamPaper_ID = paper.ID,
ExamPaper_Detail_ID = pd.ID,
Question_ID = question.ID
});
}
}
SqlMapper.CommitTransaction();
}
catch (Exception ex)
{
SqlMapper.RollBackTransaction();
throw new ApiException(ex.Message);
}
return(true);
}
/// <summary>
/// 根据ID删除单条笔记
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool DeleteNoteByID(W_QuestionNote model, string StuId)
{
W_QuestionNote NoteModel = Orm.Single <W_QuestionNote>(x => x.ID == model.ID);
if (NoteModel == null)
{
throw new ApiException("您要操作的数据不存在");
}
return(Orm.Delete <W_QuestionNote>(x => x.ID == model.ID) > 0);
}
/// <summary>
/// 删除纠错
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool DeleteQuestionerrorCorrection(W_QuestionerrorCorrection model)
{
W_QuestionerrorCorrection CorrectionModel = Orm.Single <W_QuestionerrorCorrection>(x => x.ID == model.ID);
if (CorrectionModel == null)
{
throw new ApiException("您要操作的数据不存在");
}
return(Orm.Delete <W_QuestionerrorCorrection>(x => x.ID == model.ID) > 0);
}
/// <summary>
/// 添加收藏/取消收藏
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool AddCollection(W_Collection model)
{
W_Collection CollectionModel = Orm.Single <W_Collection>(x => x.BusType == model.BusType & x.BusID == model.BusID && x.StuID == model.StuID);
if (CollectionModel == null)
{
return(Orm.Insert(model) > 0);
}
else
{
return(Orm.Delete <W_Collection>(x => x.BusID == model.BusID && x.StuID == model.StuID && x.BusType == model.BusType) > 0);
}
}
/// <summary>
/// 删除教室
/// </summary>
/// <returns></returns>
public bool DeleteClassRoom(ClassRoomModel Model, int System_Station_ID)
{
W_ClassRoom ClassRoomModel = Orm.Single <W_ClassRoom>(x => x.ID == Model.ID && x.System_Station_ID == System_Station_ID);
if (ClassRoomModel == null)
{
throw new ApiException("操作失败，您要删除的教室不存在");
}
if (Orm.Delete(ClassRoomModel) <= 0)
{
throw new ApiException("删除失败，请重试");
}
return(true);
}
/// <summary>
/// 删除课件
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public dynamic DeleteCourseWare(CourseWareModel model, int System_Station_ID)
{
W_CourseWare CourseWareModel = Orm.Single <W_CourseWare>(x => x.ID == model.ID && x.System_Station_ID == System_Station_ID);
if (CourseWareModel == null)
{
throw new ApiException("操作失败，未找到操作数据，请刷新重试");
}
W_Course_Chapters chaptersmodel = Orm.Single <W_Course_Chapters>(x => x.CourseWare_ID == model.ID && x.System_Station_ID == System_Station_ID);
if (chaptersmodel != null)
{
throw new ApiException("章节应用了该课件，请先删除课件");
}
return(Orm.Delete(CourseWareModel));
}
public Task <int> DeleteAsync(IEnumerable <int> ids,
CancellationToken cancellationToken = new CancellationToken())
{
if (typeof(TEntity).IsAssignableFrom(typeof(ISoftDeleteEntity)))
{
return(Orm.Update <TEntity>()
.Set(a => (a as ISoftDeleteEntity).IsDelete, true)
.Set(a => (a as ISoftDeleteEntity).DeleteUserId, _currentUser.Id)
.Set(a => (a as ISoftDeleteEntity).DeleteTime, DateTime.Now)
.Where(a => ids.Contains(a.Id))
.ExecuteAffrowsAsync(cancellationToken));
}
return(Orm.Delete <TEntity>(ids)
.ExecuteAffrowsAsync(cancellationToken));
}
/// <summary>
/// //点赞&取消点赞
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public bool UpdateCommentThumbsup(CampusModel model, string StuId)
{
W_Comment_Thumbsup ThumbsupModel = Orm.Single <W_Comment_Thumbsup>(x => x.Comment_ID == model.Comment_ID && x.Student_ID == StuId);
if (ThumbsupModel == null)
{
W_Comment_Thumbsup Model = new W_Comment_Thumbsup();
Model.Comment_ID = model.Comment_ID;
Model.Student_ID = StuId;
Model.AddTime = DateTime.Now;
return(Orm.Insert <W_Comment_Thumbsup>(Model) > 0);
}
else
{
return(Orm.Delete <W_Comment_Thumbsup>(x => x.Student_ID == StuId && x.Comment_ID == model.Comment_ID) > 0);
}
}
/// <summary>
///删除学科及对应的关系表 DeleteDiscipline
/// </summary>
public bool RemoveDiscipline(int ID, int System_Station_ID)
{
if (ID <= 0)
{
throw new ApiException("无效参数!");
}
//判断是不是该机构添加的学科
W_Discipline model = Orm.Single <W_Discipline>(x => x.ID == ID && x.System_Station_ID == System_Station_ID);
if (model == null)
{
throw new ApiException("操作失败，未找到对应的数据！");
}
///判断学科启用状态
if (model.Valid == 1)
{
throw new ApiException("学科启用状态，不能删除！");
}
W_Discipline modelCid = Orm.Single <W_Discipline>(x => x.CID == ID && x.System_Station_ID == System_Station_ID);
///判断学科子集是否存在课程
if (modelCid != null)
{
throw new ApiException("该学科下面存在课程，不能删除！");
}
W_QuestionStore modelstore = Orm.Single <W_QuestionStore>(x => x.Discipline_ID == ID && x.System_Station_ID == System_Station_ID && x.IsDelete == 0);
///判断题库是否应用该学科
if (modelstore != null)
{
throw new ApiException("题库应用了该学科，不能删除！");
}
W_CourseWare modelware = Orm.Single <W_CourseWare>(x => x.Discipline_ID == ID && x.System_Station_ID == System_Station_ID);
///判断资源库是否应用该学科
if (modelware != null)
{
throw new ApiException("资源库应用了该学科，不能删除！");
}
//删除数据
if (Orm.Delete <W_Discipline>(x => x.ID == ID && x.System_Station_ID == System_Station_ID) > 0)
{
return(true);
}
return(false);
}
/// <summary>
/// 订单数据回滚
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public bool DeleteOrder(int id, int System_Station_ID)
{
SqlMapper.BeginTransaction();
try
{
if (Orm.Delete <W_Order>(x => x.ID == id && x.System_Station_ID == System_Station_ID) > 0)
{
Orm.Delete <W_Order_Detail>(x => x.CID == id);
}
SqlMapper.CommitTransaction();
return(true);
}
catch (Exception ex)
{
SqlMapper.RollBackTransaction();
throw ex;
}
}
/// <summary>
/// 删除章节题目
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public bool DeleteChapterQuestion(ChapterPostModel request)
{
SqlMapper.BeginTransaction();
try
{
foreach (var item in request.questionIds)
{
Orm.Delete <W_Chapter_Question>(x => x.Question_ID == item && x.Chapter_ID == request.ChapterID);
}
SqlMapper.CommitTransaction();
}
catch
{
SqlMapper.RollBackTransaction();
return(false);
}
return(true);
}
/// <summary>
/// 删除网课章节及对应的关系表
/// </summary>
/// <param name="Model"></param>
/// <returns></returns>
public dynamic DeleteCourseChapters(W_Course_Chapters Model, int System_Station_ID)
{
SqlMapper.BeginTransaction();
try
{
W_Course_Chapters model = Orm.Single <W_Course_Chapters>(x => x.ID == Model.ID && x.System_Station_ID == System_Station_ID);
if (model == null)
{
throw new ApiException("未找到对应数据，请查看再试");
}
Orm.Delete <W_Course_Chapters>(x => x.ID == Model.ID && x.System_Station_ID == System_Station_ID);
Orm.Delete <W_DataInfo>(x => x.BusID == Model.ID && x.BusType == 1);
SqlMapper.CommitTransaction();
return(true);
}
catch (Exception ex)
{
SqlMapper.RollBackTransaction();
throw ex;
}
}
/// <summary>
/// 删除单元及对应的关系表
/// </summary>
/// <param name="Model"></param>
/// <returns></returns>
public dynamic DeleteCourseUnit(W_Course_Unit Model, int System_Station_ID)
{
SqlMapper.BeginTransaction();
try
{
W_Course_Unit model = Orm.Single <W_Course_Unit>(x => x.ID == Model.ID && x.System_Station_ID == System_Station_ID);
if (model == null)
{
throw new ApiException("找不到对应数据，请重试");
}
Orm.Delete <W_Course_Unit_ClassTime>(x => x.Unit_ID == Model.ID);
Orm.Delete <W_Course_Unit>(x => x.ID == Model.ID);
Orm.Delete <W_DataInfo>(x => x.BusID == Model.ID && x.BusType == 2);
SqlMapper.CommitTransaction();
return(true);
}
catch (Exception ex)
{
SqlMapper.RollBackTransaction();
throw ex;
}
}
/// <summary>
/// 删除校区
/// </summary>
/// <returns></returns>
public bool DeleteCampus(CampusModel Model, int System_Station_ID)
{
W_Campus campusmodel = Orm.Single <W_Campus>(x => x.ID == Model.ID && x.System_Station_ID == System_Station_ID);
if (campusmodel == null)
{
throw new ApiException("操作失败，未找到要操作的数据，请刷新再试");
}
if (campusmodel.Valid == 1)
{
throw new ApiException("启用状态中，不能删除");
}
W_ClassRoom roommodel = Orm.Single <W_ClassRoom>(x => x.CampusID == Model.ID && x.System_Station_ID == System_Station_ID);
if (roommodel != null)
{
throw new ApiException("该校区下面存在教室，不能删除");
}
if (Orm.Delete(campusmodel) <= 0)
{
throw new ApiException("删除失败，请重试");
}
return(true);
}
public dynamic DeleteChapter(W_Chapter model)
{
W_Chapter oldModel = Orm.Single <W_Chapter>(x => x.ID == model.ID);
if (oldModel == null)
{
throw new ApiException("章节已删除或者不存在");
}
if (oldModel.Valid == 1)
{
throw new ApiException("已启用的章节无法删除");
}
List <W_Chapter> newmodel = Orm.Select <W_Chapter>(x => x.CID == model.ID);
if (newmodel.Count > 0)
{
throw new ApiException("请检查章下面是否存在节");
}
if (Orm.Select <W_Chapter_Question>(x => x.Chapter_ID == model.ID).Count > 0)
{
throw new ApiException("该章节包含章节练习，不能删除");
}
return(Orm.Delete <W_Chapter>(x => x.ID == model.ID));
}
/// <summary>
/// 删除单体异步
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
public Task <int> UowDeleteAsync <T>(T entity) where T : class
{
return(Orm.Delete <T>(entity).WithTransaction(UnitOfWork.GetOrBeginTransaction()).ExecuteAffrowsAsync());
}
public bool DeleteDataInfo(int ID)
{
return(Orm.Delete <W_DataInfo>(x => x.ID == ID) > 0);
}
/// <summary>
/// 删除同步 集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entitys"></param>
/// <returns></returns>
public int UowDelete <T>(IEnumerable <T> entitys) where T : class
{
return(Orm.Delete <T>(entitys).WithTransaction(UnitOfWork.GetOrBeginTransaction()).ExecuteAffrows());
}
