732 lines
37 KiB
C#
732 lines
37 KiB
C#
using CoreModels.Enums.Department;
|
||
using DepartmentBusinessLogic.HelperModels;
|
||
using DepartmentContract.BindingModels;
|
||
using DepartmentContract.Logics.IGenericEntityLogic;
|
||
using DepartmentContract.Services.IGenericEntityService;
|
||
using DepartmentContract.ViewModels;
|
||
using SecurityContract.BindingModels;
|
||
using SecurityContract.Logics.IGenericEntityLogic;
|
||
using SecurityContract.ViewModels;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Net.Http;
|
||
using System.Net.Http.Headers;
|
||
using System.Text;
|
||
using System.Text.Json;
|
||
using System.Threading.Tasks;
|
||
using ToolsModule.ManagmentDependency;
|
||
using ToolsModule.ManagmentEntity;
|
||
using ToolsModule.ManagmentExtension;
|
||
using ToolsModule.ManagmentSecurity;
|
||
|
||
namespace DepartmentBusinessLogic.BusinessLogics.GenericBusinessLogic
|
||
{
|
||
/// <summary>
|
||
/// Логика работы с историями синхронизации приказов
|
||
/// </summary>
|
||
public class OrderSyncHistoryBusinessLogic : GenericBusinessLogic<OrderSyncHistoryGetBindingModel, OrderSyncHistorySetBindingModel, OrderSyncHistoryListViewModel, OrderSyncHistoryViewModel>, IOrderSyncHistoryLogic
|
||
{
|
||
private IOrderSyncHistoryRecordLogic _recordLogic;
|
||
|
||
private IEnviromentSettingLogic _enviromentSettingLogic;
|
||
|
||
private IAcademicPlanLogic _academicPlanLogic;
|
||
|
||
private IStudentGroupLogic _groupsLogic;
|
||
|
||
private IStudentLogic _studentLogic;
|
||
|
||
private IUserLogic _userLogic;
|
||
|
||
private IUserRoleLogic _userRoleLogic;
|
||
|
||
private IRoleLogic _roleLogic;
|
||
|
||
private IOrderLogic _orderLogic;
|
||
|
||
private IOrderStudentRecordLogic _orderStudentRecordLogic;
|
||
|
||
private OrderSyncHistoryViewModel _history;
|
||
|
||
private StudentGroupListViewModel _groups;
|
||
|
||
public OrderSyncHistoryBusinessLogic(IOrderSyncHistoryService service) : base(service, "Синхронизация Приказов", AccessOperation.СинхронизацияПриказов) { }
|
||
|
||
/// <summary>
|
||
/// Синхронизация приказов по всем студентам
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public async Task<bool> SyncOrders()
|
||
{
|
||
InitLogics();
|
||
|
||
// создание логов по операции синхронизации приказов
|
||
if (!CreateHistory())
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// получение адреса сервера с приказами
|
||
var address = GetAddress();
|
||
if (address == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// подключение клиента для отправки запросов к серверу
|
||
var client = GetClinet(address);
|
||
if (client == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// получение списка студентов
|
||
var response = await client.GetAsync($"{address.Value}/univer/hs/Ulstu_StudentsInfo/v1/GetCurrentStudentsOfDepartment");
|
||
if (!response.IsSuccessStatusCode)
|
||
{
|
||
SaveLog("Не удалось получить список студентов с сервера");
|
||
return false;
|
||
}
|
||
var studentFromServer = JsonSerializer.Deserialize<StudentListSyncModel>(await response.Content.ReadAsStringAsync());
|
||
if (studentFromServer == null || studentFromServer.CurrentStudentsList == null)
|
||
{
|
||
SaveLog("Не удалось распознать список приказов по студенту");
|
||
return false;
|
||
}
|
||
if (studentFromServer.CurrentStudentsList.Count == 0)
|
||
{
|
||
SaveLog("Полученный список студентов пустой");
|
||
return false;
|
||
}
|
||
|
||
_groups = GetStudentGroups();
|
||
|
||
var students = _studentLogic.GetList(new StudentGetBindingModel());
|
||
if (students == null || students.List == null)
|
||
{
|
||
SaveErrors(_studentLogic.Errors, "Ошибка получения данных", "Не удалось получить список студентов с базы");
|
||
return false;
|
||
}
|
||
|
||
foreach (var student in students.List)
|
||
{
|
||
var studentSync = studentFromServer.CurrentStudentsList.FirstOrDefault(x => x.recordBookName == student.NumberOfBook);
|
||
// студент не найден, значит он ушел с кафедры, выясняем почему ИЛИ не совпадение групп
|
||
if (studentSync == null || student.StudentGroupName != studentSync.groupName)
|
||
{
|
||
await SyncStudentOrders(student, client, address.Value);
|
||
}
|
||
studentFromServer.CurrentStudentsList.Remove(studentSync);
|
||
}
|
||
// новые студенты и восстановленцы
|
||
foreach (var student in studentFromServer.CurrentStudentsList)
|
||
{
|
||
// восстановленцы
|
||
var deletedStudent = _studentLogic.GetElement(new StudentGetBindingModel { NumberOfBook = student.recordBookName, IgnoreDeleted = true });
|
||
if (deletedStudent != null)
|
||
{
|
||
await SyncStudentOrders(deletedStudent, client, address.Value);
|
||
continue;
|
||
}
|
||
// новые студенты
|
||
var newStudent = CreateNewStudent(student);
|
||
if (newStudent != null)
|
||
{
|
||
SaveLog($"Добавлен студент {newStudent}");
|
||
await SyncStudentOrders(newStudent, client, address.Value);
|
||
}
|
||
}
|
||
|
||
foreach(var group in _groups.List)
|
||
{
|
||
var grStudents = _studentLogic.GetList(new StudentGetBindingModel { StudentGroupId = group.Id });
|
||
if (grStudents?.List?.Count == 0)
|
||
{
|
||
_groupsLogic.Delete(new StudentGroupGetBindingModel { Id = group.Id });
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Синхронизация приказов по студенту
|
||
/// </summary>
|
||
/// <param name="studentId"></param>
|
||
/// <returns></returns>
|
||
public async Task<bool> SyncStudentOrders(Guid studentId)
|
||
{
|
||
InitLogics();
|
||
|
||
if (!CreateHistory())
|
||
{
|
||
return false;
|
||
}
|
||
SaveLog("Синхронизация приказов по студенту");
|
||
|
||
var address = GetAddress();
|
||
if (address == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var client = GetClinet(address);
|
||
if (client == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
_groups = GetStudentGroups();
|
||
|
||
var student = _studentLogic.GetElement(new StudentGetBindingModel { Id = studentId });
|
||
if (student == null)
|
||
{
|
||
SaveErrors(_studentLogic.Errors, "Ошибка получения данных", "Не удалось получить студента с базы");
|
||
return false;
|
||
}
|
||
await SyncStudentOrders(student, client, address.Value);
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Инициализаия всех логик для получения от них данных и сохранения новых
|
||
/// </summary>
|
||
private void InitLogics()
|
||
{
|
||
_recordLogic = DependencyManager.Instance.Resolve<IOrderSyncHistoryRecordLogic>();
|
||
_enviromentSettingLogic = DependencyManager.Instance.Resolve<IEnviromentSettingLogic>();
|
||
_academicPlanLogic = DependencyManager.Instance.Resolve<IAcademicPlanLogic>();
|
||
_groupsLogic = DependencyManager.Instance.Resolve<IStudentGroupLogic>();
|
||
_studentLogic = DependencyManager.Instance.Resolve<IStudentLogic>();
|
||
_orderLogic = DependencyManager.Instance.Resolve<IOrderLogic>();
|
||
_orderStudentRecordLogic = DependencyManager.Instance.Resolve<IOrderStudentRecordLogic>();
|
||
_userLogic = DependencyManager.Instance.Resolve<IUserLogic>();
|
||
_userRoleLogic = DependencyManager.Instance.Resolve<IUserRoleLogic>();
|
||
_roleLogic = DependencyManager.Instance.Resolve<IRoleLogic>();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Создаение логера действий при синхронизации приказов
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private bool CreateHistory()
|
||
{
|
||
_history = Create(new OrderSyncHistorySetBindingModel { SyncDate = DateTime.Now });
|
||
if (_history == null)
|
||
{
|
||
Errors.Add(("Ошибка создание истории", "Не удалось создать историю"));
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Получение адреса сервера
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private EnviromentSettingViewModel GetAddress()
|
||
{
|
||
var address = _enviromentSettingLogic.GetList(new EnviromentSettingGetBindingModel { Key = "SyncStudentOrderIpAddress" })?.List?.FirstOrDefault();
|
||
if (address == null || address.Value.IsEmpty())
|
||
{
|
||
SaveErrors(_enviromentSettingLogic.Errors, "Ошибка получения данных", "Не удалось получить адрес сервера для получения приказов по студентам");
|
||
return null;
|
||
}
|
||
return address;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Получение клиента для работы с сервисом приказов
|
||
/// </summary>
|
||
/// <param name="address"></param>
|
||
/// <returns></returns>
|
||
private HttpClient GetClinet(EnviromentSettingViewModel address)
|
||
{
|
||
var username = _enviromentSettingLogic.GetList(new EnviromentSettingGetBindingModel { Key = "SyncStudentOrderUserName" })?.List?.FirstOrDefault();
|
||
if (username == null || username.Value.IsEmpty())
|
||
{
|
||
SaveErrors(_enviromentSettingLogic.Errors, "Ошибка получения данных", "Не удалось получить имя пользователя для получения приказов по студентам");
|
||
return null;
|
||
}
|
||
|
||
var password = _enviromentSettingLogic.GetList(new EnviromentSettingGetBindingModel { Key = "SyncStudentOrderPassword" })?.List?.FirstOrDefault();
|
||
if (password == null || password.Value.IsEmpty())
|
||
{
|
||
SaveErrors(_enviromentSettingLogic.Errors, "Ошибка получения данных", "Не удалось получить пароль для получения приказов по студентам");
|
||
return null;
|
||
}
|
||
|
||
var client = new HttpClient
|
||
{
|
||
BaseAddress = new Uri(address.Value)
|
||
};
|
||
client.DefaultRequestHeaders.Accept.Clear();
|
||
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
|
||
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes($"{username.Value}:{password.Value}")));
|
||
|
||
return client;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Получение списка групп
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private StudentGroupListViewModel GetStudentGroups()
|
||
{
|
||
var sgs = _groupsLogic.GetList(new StudentGroupGetBindingModel());
|
||
if (sgs == null || sgs.List == null)
|
||
{
|
||
SaveErrors(_groupsLogic.Errors, "Ошибка получения данных", "Не удалось получить список групп с базы");
|
||
return null;
|
||
}
|
||
return sgs;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Получение пользователя-студента
|
||
/// </summary>
|
||
/// <param name="student"></param>
|
||
/// <returns></returns>
|
||
private UserViewModel WorkWithUser(StudentSyncModel student)
|
||
{
|
||
var userName = $"{student.lastName}{(student.firstName.IsNotEmpty() ? $" {student.firstName[0]}." : string.Empty)}{(student.patronymicName.IsNotEmpty() ? $"{student.patronymicName[0]}." : string.Empty)}";
|
||
var user = _userLogic.GetOrCreateUser(new UserGetBindingModel
|
||
{
|
||
Login = student.recordBookName
|
||
}, userName);
|
||
if (user == null)
|
||
{
|
||
if (_userLogic.Errors.Count > 0)
|
||
{
|
||
SaveErrors(_userLogic.Errors, "Ошибка получения пользователя под студента", $"Не удалось получить пользователя под студента {student.lastName} {student.firstName} {student.patronymicName}");
|
||
return null;
|
||
}
|
||
}
|
||
var role = _roleLogic.GetElement(new RoleGetBindingModel { RoleName = "Студент" });
|
||
if (role == null)
|
||
{
|
||
if (_roleLogic.Errors.Count > 0)
|
||
{
|
||
SaveErrors(_roleLogic.Errors, "Ошибка получения роли студента", $"Не удалось получить роль под студента {student.lastName} {student.firstName} {student.patronymicName}");
|
||
return null;
|
||
}
|
||
}
|
||
var link = _userRoleLogic.GetElement(new UserRoleGetBindingModel { RoleId = role.Id, UserId = user.Id });
|
||
if (link == null)
|
||
{
|
||
var manager = DependencyManager.Instance.Resolve<ISecurityManager>();
|
||
_userRoleLogic.Create(new UserRoleSetBindingModel { RoleId = role.Id, UserId = user.Id, UserIdForAccess = manager?.User });
|
||
if (_userRoleLogic.Errors.Count > 0)
|
||
{
|
||
SaveErrors(_userRoleLogic.Errors, "Ошибка создания привязки студента к роли", $"Не удалось привязать студента {student.lastName} {student.firstName} {student.patronymicName} к роли");
|
||
return null;
|
||
}
|
||
}
|
||
|
||
return user;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Создание нового студента
|
||
/// </summary>
|
||
/// <param name="student"></param>
|
||
/// <returns></returns>
|
||
private StudentViewModel CreateNewStudent(StudentSyncModel student)
|
||
{
|
||
var user = WorkWithUser(student);
|
||
if (user == null)
|
||
{
|
||
return null;
|
||
}
|
||
var newStudent = _studentLogic.Create(new StudentSetBindingModel
|
||
{
|
||
Iduniv = student.iduniv,
|
||
NumberOfBook = student.recordBookName,
|
||
UserId = user.Id,
|
||
FirstName = student.firstName,
|
||
LastName = student.lastName,
|
||
Patronymic = student.patronymicName,
|
||
StudentState = StudentState.Неопределен,
|
||
Description = string.Empty
|
||
});
|
||
if (newStudent == null)
|
||
{
|
||
SaveErrors(_studentLogic.Errors, "Ошибка добавления студента", $"Не удалось добавить студента {student.lastName} {student.firstName} {student.patronymicName}");
|
||
return null;
|
||
}
|
||
return newStudent;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Синхронизация приказов по студенту
|
||
/// </summary>
|
||
/// <param name="history"></param>
|
||
/// <param name="student"></param>
|
||
/// <param name="groups"></param>
|
||
/// <param name="client"></param>
|
||
/// <param name="address"></param>
|
||
/// <returns></returns>
|
||
private async Task SyncStudentOrders(StudentViewModel student, HttpClient client, string address)
|
||
{
|
||
var response = await client.GetAsync($"{address}/univer/hs/Ulstu_StudentsInfo/v1/GetStudentOrdersByIdAndRecordBook?iduniv={student.Iduniv}&recordBookName={student.NumberOfBook}&allOrders=sppd");
|
||
if (!response.IsSuccessStatusCode)
|
||
{
|
||
SaveLog("Не удалось получить список приказов по студенту");
|
||
return;
|
||
}
|
||
var syncOrders = JsonSerializer.Deserialize<StudentOrderListSyncModel>(await response.Content.ReadAsStringAsync());
|
||
if (syncOrders == null || syncOrders.StudentOrders == null)
|
||
{
|
||
SaveLog("Не удалось распознать список приказов по студенту");
|
||
return;
|
||
}
|
||
if (student.LastName == "Костенко" || student.LastName == "Киселева")
|
||
{
|
||
int c = 10;
|
||
}
|
||
foreach (var syncOrder in syncOrders.StudentOrders)
|
||
{
|
||
if (syncOrder.orderTypeName == "Утверждение тем курсовых работ" ||
|
||
syncOrder.orderTypeName == "Утверждение тем ВКР" ||
|
||
syncOrder.orderTypeName == "Назначение стипендии")
|
||
{
|
||
continue;
|
||
}
|
||
if (syncOrder.markOfApprove.ToLower() != "true")
|
||
{
|
||
SaveLog($"Приказ {syncOrder.clericNumber} от {syncOrder.clericDate} ({syncOrder.orderTypeName}) по студенту {student} не утврежден");
|
||
continue;
|
||
}
|
||
if (syncOrder.clericNumber.IsEmpty())
|
||
{
|
||
SaveLog($"Приказ без номера от {syncOrder.clericDate} ({student})");
|
||
continue;
|
||
}
|
||
if (syncOrder.clericDate.IsEmpty())
|
||
{
|
||
SaveLog($"Приказ {syncOrder.clericNumber} - неизвестная дата ({student})");
|
||
continue;
|
||
}
|
||
var orderType = GetOrderType(syncOrder.orderTypeName);
|
||
|
||
// пропускаем приказы, которые нас не интересуют
|
||
if (orderType == OrderType.Игнорировать)
|
||
{
|
||
continue;
|
||
}
|
||
if (orderType == OrderType.Неопределено)
|
||
{
|
||
if (syncOrder.orderTypeName != "Корректировка" && syncOrder.orderTypeName != "Смена ФИО")
|
||
{
|
||
SaveLog($"Приказ {syncOrder.clericNumber} необрабатываемого типа {syncOrder.orderTypeName} по студенту {student}");
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// пытаемся найти приказ
|
||
var order = _orderLogic.GetElement(new OrderGetBindingModel
|
||
{
|
||
OrderNumber = syncOrder.clericNumber,
|
||
OrderDate = Convert.ToDateTime(syncOrder.clericDate).Date,
|
||
OrderType = orderType
|
||
});
|
||
if (order == null)
|
||
{
|
||
// если не нашли - пытаемся создать
|
||
order = _orderLogic.Create(new OrderSetBindingModel
|
||
{
|
||
OrderNumber = syncOrder.clericNumber,
|
||
OrderDate = Convert.ToDateTime(syncOrder.clericDate).Date,
|
||
OrderType = orderType
|
||
});
|
||
if (order == null)
|
||
{
|
||
SaveErrors(_orderLogic.Errors, "Ошибка добавления приказа", $"Не удалось добавить приказ {syncOrder.clericNumber} {syncOrder.clericDate}");
|
||
continue;
|
||
}
|
||
}
|
||
|
||
var studentGroupFrom = GetStudentGroup(syncOrder.groupNameBefore, order, false);
|
||
var studentGroupTo = GetStudentGroup(syncOrder.groupNameAfter, order, syncOrder.orderSubTypeName == "Распределение по группам");
|
||
// игнорируем приказы, не связанные с нашими группами
|
||
if (studentGroupFrom == null && studentGroupTo == null && order.OrderType != OrderType.ЗачислениеСтудентов &&
|
||
syncOrder.reason != "на другой факультет")
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var orderStudentMoveType = GetOrderStudentMoveType(student, syncOrder, studentGroupFrom, studentGroupTo, out string info);
|
||
if (orderStudentMoveType == OrderStudentMoveType.Неопределено)
|
||
{
|
||
SaveLog($"Неизветсный приказ {syncOrder.orderTypeName} ({syncOrder.reason}) по студенту {student}");
|
||
continue;
|
||
}
|
||
|
||
// ищем в приказе запись по студенту
|
||
var exsistStudentOrder = _orderStudentRecordLogic.GetElement(new OrderStudentRecordGetBindingModel
|
||
{
|
||
OrderId = order.Id,
|
||
StudentId = student.Id,
|
||
OrderStudentMoveType = orderStudentMoveType
|
||
});
|
||
|
||
// если такой приказ по студенту уже есть, просто пропускаем
|
||
if (exsistStudentOrder != null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// создаем, если не нашли
|
||
var studentOrder = _orderStudentRecordLogic.Create(new OrderStudentRecordSetBindingModel
|
||
{
|
||
OrderId = order.Id,
|
||
StudentId = student.Id,
|
||
Info = info,
|
||
OrderStudentMoveType = orderStudentMoveType,
|
||
StudentGroupFromId = studentGroupFrom?.Id,
|
||
StudentGroupToId = studentGroupTo?.Id,
|
||
StudentModel = student
|
||
});
|
||
if (studentOrder == null)
|
||
{
|
||
SaveErrors(_orderStudentRecordLogic.Errors, "Ошибка добавления записи приказа по студенту", $"Не удалось добавить запись приказа {syncOrder.orderSubTypeName} по студенту {student}");
|
||
continue;
|
||
}
|
||
|
||
SaveLog($"Добавили запись к приказу {order.OrderNumber} по студенту {student} с формулировкой {info}");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Определение типа приказа
|
||
/// </summary>
|
||
/// <param name="orderTitle"></param>
|
||
/// <returns></returns>
|
||
private static OrderType GetOrderType(string orderTitle) => orderTitle switch
|
||
{
|
||
"Зачисление в вуз вне приемной кампании" => OrderType.ЗачислениеСтудентов,
|
||
"Зачисление в вуз" => OrderType.ЗачислениеСтудентов,
|
||
"Перевод из другого вуза" => OrderType.ЗачислениеСтудентов,
|
||
"Перевод" => OrderType.Перевод,
|
||
"Перевод на следующий курс" => OrderType.ДвижениеСтудентов,
|
||
"Завершение обучения" => OrderType.Отчисление,
|
||
"Уход в академический отпуск" => OrderType.ДвижениеСтудентов,
|
||
"Продление академического отпуска" => OrderType.ДвижениеСтудентов,
|
||
"Восстановление из академического отпуска" => OrderType.ДвижениеСтудентов,
|
||
"Отчисление" => OrderType.Отчисление,
|
||
"Восстановление" => OrderType.Перевод,
|
||
"Выпуск" => OrderType.ДвижениеСтудентов,
|
||
"Утверждение тем ВКР" => OrderType.Игнорировать,
|
||
_ => OrderType.Неопределено,
|
||
};
|
||
|
||
/// <summary>
|
||
/// Поиск группы по названию из приказа
|
||
/// </summary>
|
||
/// <param name="studetnGroupName"></param>
|
||
/// <param name="order"></param>
|
||
/// <param name="groups"></param>
|
||
/// <returns></returns>
|
||
private StudentGroupViewModel GetStudentGroup(string studetnGroupName, OrderViewModel order, bool isGrouping)
|
||
{
|
||
if (string.IsNullOrEmpty(studetnGroupName))
|
||
{
|
||
return null;
|
||
}
|
||
studetnGroupName = studetnGroupName.Replace("пбд", "бд");// когда-то были группы-прикладники
|
||
int orderStudyYear = order.OrderDate.Year + (order.OrderDate.Month / 7) - 1; // учебный год
|
||
var group = _groups.List.FirstOrDefault(x => GetGroupName(x, orderStudyYear) == studetnGroupName);
|
||
if (group == null && isGrouping)
|
||
{
|
||
var academicPlan = _academicPlanLogic.GetElement(new AcademicPlanGetBindingModel
|
||
{
|
||
EducationDirectionShortName = studetnGroupName.Split('-')[0],
|
||
Year = orderStudyYear
|
||
});
|
||
if (academicPlan == null)
|
||
{
|
||
SaveLog($"Не найден учебный план для группы {studetnGroupName} за {orderStudyYear} год");
|
||
return null;
|
||
}
|
||
int yearFinish = academicPlan.EducationDirectionQualification == EducationDirectionQualification.Бакалавриат ? orderStudyYear + 4 :
|
||
academicPlan.EducationDirectionQualification == EducationDirectionQualification.Магистратура ? orderStudyYear + 2 : 0;
|
||
var newGroup = _groupsLogic.Create(new StudentGroupSetBindingModel
|
||
{
|
||
AcademicPlanId = academicPlan.Id,
|
||
GroupNumber = Convert.ToInt32(studetnGroupName[^1].ToString()),
|
||
LecturerId = null,
|
||
YearEntrance = orderStudyYear,
|
||
YearFinish = yearFinish
|
||
});
|
||
if (newGroup == null)
|
||
{
|
||
SaveErrors(_groupsLogic.Errors, "Ошибка созданий группы", "Не удалось создать группу");
|
||
return null;
|
||
}
|
||
_groups = GetStudentGroups();
|
||
group = _groups.List.FirstOrDefault(x => GetGroupName(x, orderStudyYear) == studetnGroupName);
|
||
}
|
||
return group;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Получение именни группы в зависимости от нужного года
|
||
/// </summary>
|
||
/// <param name="group"></param>
|
||
/// <param name="orderStudyYear"></param>
|
||
/// <returns></returns>
|
||
private static string GetGroupName(StudentGroupViewModel group, int orderStudyYear)
|
||
{
|
||
var course = orderStudyYear > group.YearFinish
|
||
? AcademicCourse.Неопределен
|
||
: (orderStudyYear - group.YearEntrance) switch
|
||
{
|
||
0 => AcademicCourse.Курс_1,
|
||
1 => AcademicCourse.Курс_2,
|
||
2 => AcademicCourse.Курс_3,
|
||
3 => AcademicCourse.Курс_4,
|
||
4 => AcademicCourse.Курс_5,
|
||
_ => AcademicCourse.Неопределен,
|
||
};
|
||
return $"{group.EducationDirectionShortName}-{((int)course)}{group.GroupNumber}";
|
||
}
|
||
|
||
/// <summary>
|
||
/// Определение подтипа приказа
|
||
/// </summary>
|
||
/// <param name="student"></param>
|
||
/// <param name="syncOrder"></param>
|
||
/// <param name="studentGroupFrom"></param>
|
||
/// <param name="studentGroupTo"></param>
|
||
/// <param name="info"></param>
|
||
/// <returns></returns>
|
||
private static OrderStudentMoveType GetOrderStudentMoveType(StudentViewModel student, StudentOrderSyncModel syncOrder, StudentGroupViewModel studentGroupFrom,
|
||
StudentGroupViewModel studentGroupTo, out string info)
|
||
{
|
||
switch (syncOrder.orderTypeName)
|
||
{
|
||
case "Перевод":
|
||
if (syncOrder.orderSubTypeName == "Распределение по группам")
|
||
{
|
||
info = $"Распределение студента {student} в группу {studentGroupTo}";
|
||
return OrderStudentMoveType.Распределить;
|
||
}
|
||
if (studentGroupFrom != null && studentGroupTo != null)
|
||
{
|
||
info = $"Перевод студента {student} из группы {studentGroupFrom} в группу {studentGroupTo}";
|
||
return OrderStudentMoveType.ПеревестиНаДругоеНаправлениеКафедры;
|
||
}
|
||
if (studentGroupFrom == null && studentGroupTo != null)
|
||
{
|
||
info = $"Перевод студента {student} c группы {syncOrder.groupNameBefore} другой кафедры в группу {studentGroupTo}";
|
||
return OrderStudentMoveType.ПринятьПоПереводу;
|
||
}
|
||
if (studentGroupFrom != null && studentGroupTo == null)
|
||
{
|
||
info = $"Отчисление студента {student} из группы {studentGroupFrom} в связи с переводом";
|
||
return OrderStudentMoveType.ОтчислитьВСвязиСПереводом;
|
||
}
|
||
info = string.Empty;
|
||
return OrderStudentMoveType.Неопределено;
|
||
case "Зачисление в вуз вне приемной кампании":
|
||
info = $"Зачисление студента {student} по приказу";
|
||
return OrderStudentMoveType.ЗачислитьПоПриказу;
|
||
case "Зачисление в вуз":
|
||
info = $"Зачисление студента {student} по приказу";
|
||
return OrderStudentMoveType.ЗачислитьПоПриказу;
|
||
case "Перевод из другого вуза":
|
||
info = $"Перевод студента {student} с другого вуза";
|
||
return OrderStudentMoveType.ПринятьПоПереводусДругогоВуза;
|
||
case "Перевод на следующий курс":
|
||
info = $"Перевод студента {student} из группы {studentGroupFrom} на следующий курс в группу {studentGroupTo}";
|
||
return OrderStudentMoveType.ПеревестиНаСтаршийКурс;
|
||
case "Уход в академический отпуск":
|
||
DateTime? date = null;
|
||
if (syncOrder.dateEnd.IsNotEmpty())
|
||
{
|
||
date = Convert.ToDateTime(syncOrder.dateEnd);
|
||
}
|
||
info = $"Уход в АО студента {student} из группы {studentGroupFrom} до {date?.ToShortDateString() ?? string.Empty}";
|
||
return OrderStudentMoveType.ОтправитьВАкадем;
|
||
case "Продление академического отпуска":
|
||
info = $"Продление АО студента {student}";
|
||
return OrderStudentMoveType.ПродлитьАкадем;
|
||
case "Восстановление из академического отпуска":
|
||
info = $"Выход из АО студента {student} в группу {studentGroupTo}";
|
||
return OrderStudentMoveType.ВосстановитьИзАкадема;
|
||
case "Отчисление":
|
||
if (syncOrder.reason.Contains("за невыполнение учебного плана") ||
|
||
syncOrder.reason.Contains("академическую неуспеваемость") ||
|
||
syncOrder.reason.Contains("в связи с невыполнением обучающимся обязанностей по добросовестному освоению") ||
|
||
syncOrder.reason.Contains("за невыполнение обязанностей по добросовестному освоению"))
|
||
{
|
||
info = $"Отчисление студента {student} из группы {studentGroupFrom} за неуспеваемость";
|
||
return OrderStudentMoveType.ОтчислитьЗаНеуспевамость;
|
||
}
|
||
if (syncOrder.reason.Contains("по собственному желанию"))
|
||
{
|
||
info = $"Отчисление студента {student} из группы {studentGroupFrom} по собственному желанию";
|
||
return OrderStudentMoveType.ОтчислитьПоСобственному;
|
||
}
|
||
if (syncOrder.reason.Contains("в связи с невыходом из академического отпуска"))
|
||
{
|
||
info = $"Отчисление студента {student} из группы {studentGroupFrom} в связи с невыходм из академического отпуска";
|
||
return OrderStudentMoveType.ОтчислитьЗаНевыходСАкадема;
|
||
}
|
||
if (syncOrder.reason.Contains("в связи с переводом в"))
|
||
{
|
||
info = $"Отчисление студента {student} из группы {studentGroupFrom} в связи с переводом";
|
||
return OrderStudentMoveType.ОтчислитьВСвязиСПереводом;
|
||
}
|
||
if (syncOrder.reason.Contains("за невыполнение условий договора"))
|
||
{
|
||
info = $"Отчисление студента {student} из группы {studentGroupFrom} в связи с не оплатой обучения";
|
||
return OrderStudentMoveType.ОтчислитьЗаНеоплату;
|
||
}
|
||
info = string.Empty;
|
||
return OrderStudentMoveType.Неопределено;
|
||
case "Восстановление":
|
||
info = $"Восстановление отчисленного студента {student} в группу {studentGroupTo}";
|
||
return OrderStudentMoveType.Восстановить;
|
||
case "Выпуск":
|
||
info = $"Завершение обучения студента {student}";
|
||
return OrderStudentMoveType.ОтчислитьПоЗавершению;
|
||
default:
|
||
info = string.Empty;
|
||
return OrderStudentMoveType.Неопределено;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Сохранение лога с ошибками
|
||
/// </summary>
|
||
/// <param name="errors"></param>
|
||
/// <param name="title"></param>
|
||
/// <param name="message"></param>
|
||
private void SaveErrors(List<(string Title, string Message)> errors, string title, string message)
|
||
{
|
||
if (_history == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
Errors = errors ?? new List<(string Title, string Message)>();
|
||
Errors.Add((title, message));
|
||
SaveLog(string.Join(Environment.NewLine, Errors.Select(x => x.Message)));
|
||
}
|
||
|
||
/// <summary>
|
||
/// Сохранение лога
|
||
/// </summary>
|
||
/// <param name="info"></param>
|
||
private void SaveLog(string info)
|
||
{
|
||
_recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
|
||
{
|
||
OrderSyncHistoryId = _history.Id,
|
||
Information = info
|
||
});
|
||
}
|
||
}
|
||
} |