485 lines
17 KiB
C#
485 lines
17 KiB
C#
using AutoMapper;
|
||
using Microsoft.AspNetCore.Http;
|
||
using Microsoft.EntityFrameworkCore;
|
||
using Microsoft.Extensions.DependencyInjection;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Text;
|
||
using System.Threading.Tasks;
|
||
using VOL.Business.IRepositories;
|
||
using VOL.Business.IRepositories.Stadium;
|
||
using VOL.Business.IServices;
|
||
using VOL.Business.Repositories;
|
||
using VOL.Core.CacheManager;
|
||
using VOL.Core.Enums;
|
||
using VOL.Core.Extensions;
|
||
using VOL.Core.Extensions.AutofacManager;
|
||
using VOL.Core.ManageUser;
|
||
using VOL.Core.Utilities;
|
||
using VOL.Entity.DomainModels;
|
||
using VOL.Entity.DomainModels.YD;
|
||
using VOL.Model;
|
||
using VOL.Model.Ai;
|
||
using VOL.System.Repositories;
|
||
using static Dapper.SqlMapper;
|
||
|
||
namespace VOL.Business.Services
|
||
{
|
||
/// <summary>
|
||
/// 课程服务
|
||
/// </summary>
|
||
public class CurricularService : ICurricularService, IDependency
|
||
{
|
||
#region 初始化
|
||
private readonly IMapper _mapper;
|
||
private readonly ICacheService _cacheService;
|
||
private readonly ICurricularRepository _curricularRepository;
|
||
|
||
[ActivatorUtilitiesConstructor]
|
||
public CurricularService(IMapper mapper,
|
||
ICacheService cacheService,
|
||
ICurricularRepository curricularRepository)
|
||
{
|
||
_mapper = mapper;
|
||
_cacheService = cacheService;
|
||
_curricularRepository = curricularRepository;
|
||
}
|
||
#endregion
|
||
|
||
|
||
/// <summary>
|
||
/// 查询课程分类
|
||
/// </summary>
|
||
/// <param name="dto"></param>
|
||
/// <returns></returns>
|
||
public async Task<PageDataDto<CourseCategoryDto>> GetCourseCategories(CourseCategoryVo dto)
|
||
{
|
||
// 实现查询逻辑
|
||
var res = new PageDataDto<CourseCategoryDto>();
|
||
// 示例查询逻辑
|
||
var query = from c in _curricularRepository.DbContext.Set<Y_CurricularTaxonomy>()
|
||
select new CourseCategoryDto()
|
||
{
|
||
Id = c.Id,
|
||
CategoryName = c.TaxonomyName
|
||
};
|
||
|
||
if (!string.IsNullOrWhiteSpace(dto.CategoryName))
|
||
{
|
||
query = query.Where(x => x.CategoryName.Contains(dto.CategoryName));
|
||
}
|
||
|
||
res.Total = await query.CountAsync();
|
||
|
||
var list = await query
|
||
.Skip((dto.PageIndex - 1) * dto.PageSize)
|
||
.Take(dto.PageSize)
|
||
.OrderBy(x => x.Id)
|
||
.ToListAsync();
|
||
res.Datas = list;
|
||
|
||
return res;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 新增课程分类
|
||
/// </summary>
|
||
/// <param name="dto"></param>
|
||
/// <returns></returns>
|
||
public async Task AddCourseCategory(CourseCategoryDto dto)
|
||
{
|
||
// 实现新增逻辑
|
||
var entity = new Y_CurricularTaxonomy
|
||
{
|
||
TaxonomyName = dto.CategoryName
|
||
};
|
||
_curricularRepository.Add<Y_CurricularTaxonomy>(entity);
|
||
await _curricularRepository.SaveChangesAsync();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新课程分类
|
||
/// </summary>
|
||
/// <param name="dto"></param>
|
||
/// <returns></returns>
|
||
public async Task UpdateCourseCategory(CourseCategoryDto dto)
|
||
{
|
||
// 实现更新逻辑
|
||
var entity = await _curricularRepository.FindAsyncFirst<Y_CurricularTaxonomy>(c => c.Id == dto.Id);
|
||
if (entity != null)
|
||
{
|
||
entity.TaxonomyName = dto.CategoryName;
|
||
// 其他属性更新
|
||
_curricularRepository.Update<Y_CurricularTaxonomy>(entity);
|
||
await _curricularRepository.SaveChangesAsync();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 删除课程分类
|
||
/// </summary>
|
||
/// <param name="categoryId"></param>
|
||
/// <returns></returns>
|
||
public async Task DeleteCourseCategory(int categoryId)
|
||
{
|
||
// 实现删除逻辑
|
||
var entity = await _curricularRepository.FindAsyncFirst<Y_CurricularTaxonomy>(c => c.Id == categoryId);
|
||
if (entity != null)
|
||
{
|
||
_curricularRepository.Delete<Y_CurricularTaxonomy>(entity);
|
||
await _curricularRepository.SaveChangesAsync();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 课程列表
|
||
/// </summary>
|
||
/// <param name="dto"></param>
|
||
/// <returns></returns>
|
||
public async Task<PageDataDto<CurricularListDto>> GetCurricularList(CurricularListVo dto)
|
||
{
|
||
var res = new PageDataDto<CurricularListDto>();
|
||
|
||
var query = from c in _curricularRepository.DbContext.Set<Y_Curricular>()
|
||
join t in _curricularRepository.DbContext.Set<Y_CurricularTaxonomy>()
|
||
on c.TaxonomyId equals t.Id into taxonomyGroup
|
||
from t in taxonomyGroup.DefaultIfEmpty()
|
||
select new CurricularListDto()
|
||
{
|
||
Id = c.Id,
|
||
TaxonomyId = c.TaxonomyId,
|
||
TaxonomyName = t != null ? t.TaxonomyName : string.Empty,
|
||
CurricularName = c.CurricularName,
|
||
CoverImage = c.CoverImage,
|
||
Url = c.Url,
|
||
Hits = c.Hits,
|
||
CreateDate = c.CreateDate
|
||
};
|
||
|
||
if (dto.TaxonomyId.HasValue)
|
||
{
|
||
query = query.Where(x => x.TaxonomyId == dto.TaxonomyId.Value);
|
||
}
|
||
|
||
if (!string.IsNullOrWhiteSpace(dto.CurricularName))
|
||
{
|
||
query = query.Where(x => x.CurricularName.Contains(dto.CurricularName));
|
||
}
|
||
|
||
if (dto.StartTime.HasValue)
|
||
{
|
||
query = query.Where(x => x.CreateDate >= dto.StartTime.Value);
|
||
}
|
||
|
||
if (dto.EndTime.HasValue)
|
||
{
|
||
query = query.Where(x => x.CreateDate <= dto.EndTime.Value);
|
||
}
|
||
|
||
res.Total = await query.CountAsync();
|
||
|
||
var list = await query
|
||
.OrderByDescending(x => x.CreateDate)
|
||
.Skip((dto.PageIndex - 1) * dto.PageSize)
|
||
.Take(dto.PageSize)
|
||
.ToListAsync();
|
||
|
||
res.Datas = list;
|
||
|
||
return res;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 新增课程
|
||
/// </summary>
|
||
/// <param name="dto"></param>
|
||
/// <returns></returns>
|
||
public async Task AddCurricular(CurricularAddDto dto)
|
||
{
|
||
var entity = new Y_Curricular
|
||
{
|
||
TaxonomyId = dto.TaxonomyId,
|
||
CurricularName = dto.CurricularName,
|
||
CoverImage = dto.CoverImage,
|
||
Url = dto.Url,
|
||
Hits = 0,
|
||
CreateDate = DateTime.Now
|
||
};
|
||
|
||
_curricularRepository.Add<Y_Curricular>(entity);
|
||
await _curricularRepository.SaveChangesAsync();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取课程详情
|
||
/// </summary>
|
||
/// <param name="courseId"></param>
|
||
/// <returns></returns>
|
||
public async Task<CurricularAddDto> GetCourseDetails(int courseId)
|
||
{
|
||
var course = await _curricularRepository.DbContext.Set<Y_Curricular>()
|
||
.FirstOrDefaultAsync(c => c.Id == courseId);
|
||
if (course == null)
|
||
{
|
||
throw new Exception("课程不存在");
|
||
}
|
||
|
||
var taxonomies = await _curricularRepository.FindAsync<Y_CurricularTaxonomy>(c => true);
|
||
|
||
return new CurricularAddDto
|
||
{
|
||
Id = course.Id,
|
||
CurricularName = course.CurricularName,
|
||
CoverImage = course.CoverImage,
|
||
Url = course.Url,
|
||
TaxonomyId = course.TaxonomyId,
|
||
TaxonomyName = taxonomies.FirstOrDefault(c => c.Id == course.TaxonomyId).TaxonomyName,
|
||
CreateDate = course.CreateDate.GetValueOrDefault()
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新课程
|
||
/// </summary>
|
||
/// <param name="dto"></param>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
public async Task UpdateCourse(CurricularAddDto dto)
|
||
{
|
||
var course = await _curricularRepository.FindAsyncFirst<Y_Curricular>(c => c.Id == dto.Id);
|
||
|
||
if (course == null)
|
||
{
|
||
throw new Exception("课程不存在");
|
||
}
|
||
|
||
ALiYunOss.DeleteFilesByPrefix(course.CoverImage);
|
||
ALiYunOss.DeleteFilesByPrefix(course.Url);
|
||
|
||
course.CurricularName = dto.CurricularName;
|
||
course.CoverImage = dto.CoverImage;
|
||
course.Url = dto.Url;
|
||
course.TaxonomyId = dto.TaxonomyId;
|
||
course.ModifyDate = DateTime.Now;
|
||
|
||
_curricularRepository.Update(course);
|
||
await _curricularRepository.SaveChangesAsync();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 删除课程
|
||
/// </summary>
|
||
/// <param name="courseId"></param>
|
||
/// <returns></returns>
|
||
/// <exception cref="Exception"></exception>
|
||
public async Task DeleteCourse(int courseId)
|
||
{
|
||
var course = await _curricularRepository.FindAsyncFirst<Y_Curricular>(c => c.Id == courseId);
|
||
if (course == null)
|
||
{
|
||
throw new Exception("课程不存在");
|
||
}
|
||
|
||
ALiYunOss.DeleteFilesByPrefix(course.CoverImage);
|
||
ALiYunOss.DeleteFilesByPrefix(course.Url);
|
||
|
||
_curricularRepository.Delete<Y_Curricular>(course);
|
||
await _curricularRepository.SaveChangesAsync();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 热门课程列表查询
|
||
/// </summary>
|
||
/// <param name="dto">查询参数</param>
|
||
/// <returns>热门课程列表</returns>
|
||
public async Task<PageDataDto<PopularCurricularDto>> GetPopularCurricularList(PopularCurricularVo dto)
|
||
{
|
||
var res = new PageDataDto<PopularCurricularDto>();
|
||
|
||
// 验证展示数量至少为2
|
||
if (dto.DisplayMode == "自动" && dto.DisplayCount.HasValue && dto.DisplayCount.Value < 2)
|
||
{
|
||
throw new Exception("最少展示2节课程");
|
||
}
|
||
|
||
// 手动模式：从热门课程表中查询
|
||
if (dto.DisplayMode == "手动" || string.IsNullOrEmpty(dto.DisplayMode))
|
||
{
|
||
var query = from p in _curricularRepository.DbContext.Set<Y_PopularCurricular>()
|
||
join c in _curricularRepository.DbContext.Set<Y_Curricular>()
|
||
on p.CurricularId equals c.Id
|
||
join t in _curricularRepository.DbContext.Set<Y_CurricularTaxonomy>()
|
||
on c.TaxonomyId equals t.Id into taxonomyGroup
|
||
from t in taxonomyGroup.DefaultIfEmpty()
|
||
select new PopularCurricularDto
|
||
{
|
||
Id = p.Id,
|
||
CurricularId = p.CurricularId,
|
||
CurricularTaxonomyName = t != null ? t.TaxonomyName : string.Empty,
|
||
CurricularName = c.CurricularName,
|
||
CoverImage = c.CoverImage,
|
||
Hits = c.Hits,
|
||
CreateDate = c.CreateDate,
|
||
Remarks = p.Remarks
|
||
};
|
||
|
||
res.Total = await query.CountAsync();
|
||
|
||
var list = await query
|
||
.Skip((dto.PageIndex - 1) * dto.PageSize)
|
||
.Take(dto.PageSize)
|
||
.OrderByDescending(x => x.Id)
|
||
.ToListAsync();
|
||
res.Datas = list;
|
||
}
|
||
// 自动模式：根据规则从课程表中查询
|
||
else if (dto.DisplayMode == "自动")
|
||
{
|
||
var query = from c in _curricularRepository.DbContext.Set<Y_Curricular>()
|
||
join t in _curricularRepository.DbContext.Set<Y_CurricularTaxonomy>()
|
||
on c.TaxonomyId equals t.Id into taxonomyGroup
|
||
from t in taxonomyGroup.DefaultIfEmpty()
|
||
select new PopularCurricularDto
|
||
{
|
||
Id = c.Id, // 自动模式下，Id为0
|
||
CurricularId = c.Id,
|
||
CurricularTaxonomyName = t != null ? t.TaxonomyName : string.Empty,
|
||
CurricularName = c.CurricularName,
|
||
CoverImage = c.CoverImage,
|
||
Hits = c.Hits,
|
||
CreateDate = c.CreateDate,
|
||
Remarks = ""
|
||
};
|
||
|
||
// 根据展示规则排序
|
||
if (dto.DisplayRule == "最新上传")
|
||
{
|
||
query = query.OrderByDescending(x => x.CreateDate);
|
||
}
|
||
else if (dto.DisplayRule == "流量最大")
|
||
{
|
||
query = query.OrderByDescending(x => x.Hits);
|
||
}
|
||
else
|
||
{
|
||
query = query.OrderByDescending(x => x.CreateDate);
|
||
}
|
||
|
||
// 如果设置了展示数量，则按照展示数量返回
|
||
if (dto.DisplayCount.HasValue)
|
||
{
|
||
res.Total = Math.Min(await query.CountAsync(), dto.DisplayCount.Value);
|
||
var list = await query.Take(dto.DisplayCount.Value).ToListAsync();
|
||
res.Datas = list;
|
||
}
|
||
else
|
||
{
|
||
res.Total = await query.CountAsync();
|
||
var list = await query
|
||
.Skip((dto.PageIndex - 1) * dto.PageSize)
|
||
.Take(dto.PageSize)
|
||
.ToListAsync();
|
||
res.Datas = list;
|
||
}
|
||
}
|
||
|
||
return res;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 添加热门课程
|
||
/// </summary>
|
||
/// <param name="dto">课程ID列表</param>
|
||
/// <returns></returns>
|
||
public async Task AddPopularCurricular(AddPopularCurricularDto dto)
|
||
{
|
||
if (dto.CurricularIds == null || !dto.CurricularIds.Any())
|
||
{
|
||
throw new Exception("课程ID不能为空");
|
||
}
|
||
|
||
// 验证课程是否存在
|
||
var curriculars = await _curricularRepository.DbContext.Set<Y_Curricular>()
|
||
.Where(c => dto.CurricularIds.Contains(c.Id))
|
||
.ToListAsync();
|
||
|
||
if (curriculars.Count != dto.CurricularIds.Count)
|
||
{
|
||
throw new Exception("部分课程不存在");
|
||
}
|
||
|
||
// 验证课程是否已经是热门课程
|
||
var existingPopulars = await _curricularRepository.DbContext.Set<Y_PopularCurricular>()
|
||
.Where(p => dto.CurricularIds.Contains(p.CurricularId))
|
||
.Select(p => p.CurricularId)
|
||
.ToListAsync();
|
||
|
||
// 过滤掉已经存在的课程ID
|
||
var newCurricularIds = dto.CurricularIds.Except(existingPopulars).ToList();
|
||
|
||
if (!newCurricularIds.Any())
|
||
{
|
||
throw new Exception("所选课程已经是热门课程");
|
||
}
|
||
|
||
// 批量添加热门课程
|
||
var entities = newCurricularIds.Select(id => new Y_PopularCurricular
|
||
{
|
||
CurricularId = id,
|
||
CreateDate = DateTime.Now,
|
||
Creator = UserContext.Current.UserId
|
||
}).ToList();
|
||
|
||
_curricularRepository.AddRange<Y_PopularCurricular>(entities);
|
||
await _curricularRepository.SaveChangesAsync();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 删除热门课程
|
||
/// </summary>
|
||
/// <param name="id">热门课程ID</param>
|
||
/// <returns></returns>
|
||
public async Task DeletePopularCurricular(int id)
|
||
{
|
||
var entity = await _curricularRepository.FindAsyncFirst<Y_PopularCurricular>(c => c.Id == id);
|
||
if (entity == null)
|
||
{
|
||
throw new Exception("热门课程不存在");
|
||
}
|
||
|
||
_curricularRepository.Delete(entity);
|
||
await _curricularRepository.SaveChangesAsync();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 上传视频
|
||
/// </summary>
|
||
public async Task<string> UploadVideo(IFormFile file)
|
||
{
|
||
var timeStampString = DateTime.Now.ToUnixTimeStamp();
|
||
var prefix = $"Upload/Curricular/";
|
||
// 删除文件
|
||
//ALiYunOss.DeleteFilesByPrefix(prefix);
|
||
// 上传文件
|
||
var url = ALiYunOss.Upload(file, prefix, timeStampString);
|
||
|
||
return url;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 上传封面图像
|
||
/// </summary>
|
||
/// <param name="file"></param>
|
||
/// <returns></returns>
|
||
public string UploadImage(IFormFile file)
|
||
{
|
||
var timeStampString = DateTime.Now.ToUnixTimeStamp();
|
||
var prefix = $"Upload/Curricular/";
|
||
|
||
var url = ALiYunOss.Upload(file, prefix, timeStampString);
|
||
|
||
return url;
|
||
}
|
||
}
|
||
} |