TechHelper/TechHelper.Server/Services/ClassService.cs

using AutoMapper;
using Entities.Contracts;
using Entities.DTO;
using Microsoft.AspNetCore.Identity;
using Org.BouncyCastle.Crypto;
using SharedDATA.Api;

namespace TechHelper.Services
{
	public class ClassService : IClassService
	{
		private readonly IUnitOfWork _work;
		private readonly IMapper _mapper;
		private readonly UserManager<User> _userManager;

		public ClassService(IUnitOfWork work, IMapper mapper, UserManager<User> userManager)
		{
			_work = work;
			_mapper = mapper;
			_userManager = userManager;
		}

		public async Task<ApiResponse> AddAsync(ClassDto model)
		{
			try
			{
				var @class = _mapper.Map<Class>(model);
				await _work.GetRepository<Class>().InsertAsync(@class);

				if (await _work.SaveChangesAsync() > 0)
				{
					return new ApiResponse(true, _mapper.Map<ClassDto>(@class));
				}
				return new ApiResponse("添加班级失败。");
			}
			catch (Exception ex)
			{
				return new ApiResponse($"添加班级时发生错误: {ex.Message}");
			}
		}

		// 实现 IBaseService<ClassDto, int>.DeleteAsync
		public async Task<ApiResponse> DeleteAsync(Guid id) // ID 类型现在是 int
		{
			try
			{
				var existingClass = await _work.GetRepository<Class>().GetFirstOrDefaultAsync(
					predicate: c => c.Id == id);

				if (existingClass == null)
				{
					return new ApiResponse("班级未找到。");
				}

				_work.GetRepository<Class>().Delete(existingClass);

				if (await _work.SaveChangesAsync() > 0)
				{
					return new ApiResponse(true, "班级删除成功。");
				}
				return new ApiResponse("删除班级失败。");
			}
			catch (Exception ex)
			{
				return new ApiResponse($"删除班级时发生错误: {ex.Message}");
			}
		}

		// 实现 IBaseService<ClassDto, int>.GetAllAsync
		public async Task<ApiResponse> GetAllAsync(QueryParameter query)
		{
			try
			{
				var repository = _work.GetRepository<Class>();

				// 构建查询条件 (可根据 QueryParameter.Search 进行筛选)
				Func<IQueryable<Class>, IOrderedQueryable<Class>> orderBy = null; // 默认不排序
				if (query.Search != null && !string.IsNullOrWhiteSpace(query.Search))
				{
					// 在 Name 字段中进行模糊搜索
					var classes = await repository.GetPagedListAsync(
						orderBy: orderBy,
						pageSize: query.PageSize,
						pageIndex: query.PageIndex
					);
					var classDtosFiltered = _mapper.Map<IEnumerable<ClassDto>>(classes);
					return new ApiResponse(true, classDtosFiltered);
				}
				else
				{
					// 如果没有搜索条件，获取所有（带分页）
					var classes = await repository.GetPagedListAsync(
						orderBy: orderBy,
						pageSize: query.PageSize,
						pageIndex: query.PageIndex
					);
					var classDtos = _mapper.Map<IEnumerable<ClassDto>>(classes);
					return new ApiResponse(true, classDtos);
				}
			}
			catch (Exception ex)
			{
				return new ApiResponse($"获取所有班级时发生错误: {ex.Message}");
			}
		}

		// 实现 IBaseService<ClassDto, int>.GetAsync
		public async Task<ApiResponse> GetAsync(Guid id) 
		{
			try
			{
				var @class = await _work.GetRepository<Class>().GetFirstOrDefaultAsync(
					predicate: c => c.Id == id);

				if (@class == null)
				{
					return new ApiResponse("班级未找到。");
				}

				var classDto = _mapper.Map<ClassDto>(@class);
				return new ApiResponse(true, classDto);
			}
			catch (Exception ex)
			{
				return new ApiResponse($"获取班级时发生错误: {ex.Message}");
			}
		}

		public async Task<ApiResponse> GetUserClass(Guid user)
		{
			var existingUserClass = await _work.GetRepository<ClassStudent>().GetFirstOrDefaultAsync(predicate: c=>c.StudentId == user);
			if(existingUserClass == null) return new ApiResponse("该学生没有班级。");

			var classId = await _work.GetRepository<Class>().GetFirstOrDefaultAsync(predicate: c => c.Id == existingUserClass.ClassId);
			return new ApiResponse(true, (classId.Grade, classId.Number));
		}

		// 实现 IBaseService<ClassDto, int>.UpdateAsync
		public async Task<ApiResponse> UpdateAsync(ClassDto model)
		{
			try
			{
				// 首先通过 ID 查找现有实体
				var existingClass = await _work.GetRepository<Class>().GetFirstOrDefaultAsync(
					predicate: c => c.Number == model.Class); 

				if (existingClass == null)
				{
					return new ApiResponse("班级未找到。");
				}

				_mapper.Map(model, existingClass); 
				_work.GetRepository<Class>().Update(existingClass);

				if (await _work.SaveChangesAsync() > 0)
				{
					return new ApiResponse(true, _mapper.Map<ClassDto>(existingClass));
				}
				return new ApiResponse("更新班级失败。");
			}
			catch (Exception ex)
			{
				return new ApiResponse($"更新班级时发生错误: {ex.Message}");
			}
		}

		public async Task<ApiResponse> UserRegister(UserRegistrationToClassDto user)
		{
			try
			{
				var usrinfo = await _userManager.FindByEmailAsync(user.User);
				var existingClass = await _work.GetRepository<Class>().GetFirstOrDefaultAsync(
					predicate: (c => c.Number == user.ClassId && c.Grade == user.GradeId));

				var finduser = await _userManager.FindByEmailAsync(user.User);

				if (existingClass == null || finduser == null || usrinfo == null)
				{
					return new ApiResponse("班级未找到。");
				}



				if (user.Roles == UserRoles.Student)
				{
					var addresult = await _work.GetRepository<ClassStudent>().InsertAsync(new ClassStudent
					{
						StudentId = finduser.Id,
						ClassId = existingClass.Id
					});

					await _userManager.AddToRoleAsync(usrinfo, UserRoles.Student.ToString());
				}
				else if (user.Roles == UserRoles.Teacher)
				{
					var classTeacher = new ClassTeacher
					{
						ClassId = existingClass.Id,
						TeacherId = existingClass.Id,
						SubjectTaught = user.SubjectArea.ToString()
					};
					await _work.GetRepository<ClassTeacher>().InsertAsync(classTeacher);

					await _userManager.AddToRoleAsync(usrinfo, UserRoles.Teacher.ToString());
				}

				if (await _work.SaveChangesAsync() > 0)
				{
					return new ApiResponse(true, _mapper.Map<ClassDto>(existingClass));
				}
				return new ApiResponse("班级注册失败。");

			}
			catch (Exception ex) { return new ApiResponse($"注册进班级时发生错误: {ex.Message}"); }
		}
	}
}