703 lines
37 KiB
C#
703 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.ManagmentMapping;
|
||
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 IStudentGroupLogic _groupsLogic;
|
||
|
||
private IStudentLogic _studentLogic;
|
||
|
||
private IUserLogic _userLogic;
|
||
|
||
private IUserRoleLogic _userRoleLogic;
|
||
|
||
private IRoleLogic _roleLogic;
|
||
|
||
private IOrderLogic _orderLogic;
|
||
|
||
private IOrderStudentRecordLogic _orderStudentRecordLogic;
|
||
|
||
private OrderSyncHistoryViewModel _history;
|
||
|
||
public OrderSyncHistoryBusinessLogic(IOrderSyncHistoryService service) : base(service, "Синхронизация Приказов", AccessOperation.СинхронизацияПриказов) { }
|
||
|
||
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;
|
||
}
|
||
|
||
var groups = _groupsLogic.GetList(new StudentGroupGetBindingModel());
|
||
if (groups == null || groups.List == null)
|
||
{
|
||
SaveErrors(_groupsLogic.Errors, "Ошибка получения данных", "Не удалось получить список групп с базы");
|
||
return false;
|
||
}
|
||
|
||
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)
|
||
{
|
||
await SyncStudentOrders(student, groups.List, client, address.Value);
|
||
}
|
||
// не совпадение групп
|
||
else if (student.StudentGroupName != studentSync.groupName)
|
||
{
|
||
await SyncStudentOrders(student, groups.List, 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, groups.List, client, address.Value);
|
||
continue;
|
||
}
|
||
|
||
var newStudent = CreateNewStudent(student);
|
||
if (newStudent != null)
|
||
{
|
||
SaveLog($"Добавлен студент {newStudent}");
|
||
await SyncStudentOrders(newStudent, groups.List, client, address.Value);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
var groups = _groupsLogic.GetList(new StudentGroupGetBindingModel());
|
||
if (groups == null || groups.List == null)
|
||
{
|
||
SaveErrors(_groupsLogic.Errors, "Ошибка получения данных", "Не удалось получить список групп с базы");
|
||
return false;
|
||
}
|
||
|
||
var student = _studentLogic.GetElement(new StudentGetBindingModel { Id = studentId });
|
||
if (student == null)
|
||
{
|
||
SaveErrors(_studentLogic.Errors, "Ошибка получения данных", "Не удалось получить студента с базы");
|
||
return false;
|
||
}
|
||
await SyncStudentOrders(student, groups.List, client, address.Value);
|
||
return true;
|
||
}
|
||
|
||
private void InitLogics()
|
||
{
|
||
_recordLogic = DependencyManager.Instance.Resolve<IOrderSyncHistoryRecordLogic>();
|
||
_enviromentSettingLogic = DependencyManager.Instance.Resolve<IEnviromentSettingLogic>();
|
||
_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>();
|
||
}
|
||
|
||
private bool CreateHistory()
|
||
{
|
||
_history = Create(new OrderSyncHistorySetBindingModel { SyncDate = DateTime.Now });
|
||
if (_history == null)
|
||
{
|
||
Errors.Add(("Ошибка создание истории", "Не удалось создать историю"));
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
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, List<StudentGroupViewModel> groups, 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;
|
||
}
|
||
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}");
|
||
}
|
||
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;
|
||
}
|
||
}
|
||
|
||
StudentGroupViewModel studentGroupFrom = null;
|
||
StudentGroupViewModel studentGroupTo = null;
|
||
if (syncOrder.groupNameBefore.IsNotEmpty())
|
||
{
|
||
syncOrder.groupNameBefore = syncOrder.groupNameBefore.Replace("пбд", "бд");
|
||
studentGroupFrom = groups.FirstOrDefault(x => x.GroupName == syncOrder.groupNameBefore || x.ToString() == syncOrder.groupNameBefore);
|
||
}
|
||
if (syncOrder.groupNameAfter.IsNotEmpty())
|
||
{
|
||
syncOrder.groupNameAfter = syncOrder.groupNameAfter.Replace("пбд", "бд");
|
||
studentGroupTo = groups.FirstOrDefault(x => x.GroupName == syncOrder.groupNameAfter || x.ToString() == syncOrder.groupNameAfter);
|
||
}
|
||
// игнорируем приказы, не связанные с нашими группами
|
||
if (studentGroupFrom == null && syncOrder.groupNameBefore.IsNotEmpty() && studentGroupTo == null && syncOrder.groupNameAfter.IsNotEmpty())
|
||
{
|
||
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;
|
||
}
|
||
|
||
SetYearFinish(student, studentGroupTo, order, orderStudentMoveType);
|
||
|
||
// создаем, если не нашли
|
||
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}");
|
||
|
||
if (orderStudentMoveType == OrderStudentMoveType.ОтчислитьВСвязиСПереводом ||
|
||
orderStudentMoveType == OrderStudentMoveType.ОтчислитьЗаНевыходСАкадема ||
|
||
orderStudentMoveType == OrderStudentMoveType.ОтчислитьЗаНеуспевамость ||
|
||
orderStudentMoveType == OrderStudentMoveType.ОтчислитьПоЗавершению ||
|
||
orderStudentMoveType == OrderStudentMoveType.ОтчислитьПоСобственному)
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
private static OrderType GetOrderType(string orderTitle) => orderTitle switch
|
||
{
|
||
"Зачисление в вуз вне приемной кампании" => OrderType.ЗачислениеСтудентов,
|
||
"Зачисление в вуз" => OrderType.ЗачислениеСтудентов,
|
||
"Перевод из другого вуза" => OrderType.ЗачислениеСтудентов,
|
||
"Перевод" => OrderType.Перевод,
|
||
"Перевод на следующий курс" => OrderType.ДвижениеСтудентов,
|
||
"Завершение обучения" => OrderType.Отчисление,
|
||
"Уход в академический отпуск" => OrderType.ДвижениеСтудентов,
|
||
"Продление академического отпуска" => OrderType.ДвижениеСтудентов,
|
||
"Восстановление из академического отпуска" => OrderType.ДвижениеСтудентов,
|
||
"Отчисление" => OrderType.Отчисление,
|
||
"Восстановление" => OrderType.Перевод,
|
||
"Выпуск" => OrderType.ДвижениеСтудентов,
|
||
"Утверждение тем ВКР" => OrderType.Игнорировать,
|
||
_ => OrderType.Неопределено,
|
||
};
|
||
|
||
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} на другую кафедру в группу {syncOrder.groupNameAfter}";
|
||
return OrderStudentMoveType.УбратьПоПереводу;
|
||
}
|
||
if (syncOrder.reason == "на другой факультет")
|
||
{
|
||
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 "Отчисление":
|
||
switch (syncOrder.reason)
|
||
{
|
||
case "за невыполнение учебного плана":
|
||
info = $"Отчисление студента {student} из группы {studentGroupFrom} за неуспеваемость";
|
||
return OrderStudentMoveType.ОтчислитьЗаНеуспевамость;
|
||
case "по собственному желанию":
|
||
info = $"Отчисление студента {student} из группы {studentGroupFrom} по собственному желанию";
|
||
return OrderStudentMoveType.ОтчислитьПоСобственному;
|
||
case "в связи с невыходом из академического отпуска":
|
||
info = $"Отчисление студента {student} из группы {studentGroupFrom} в связи с невыходм из академического отпуска";
|
||
return OrderStudentMoveType.ОтчислитьЗаНевыходСАкадема;
|
||
case "за невыполнение обязанностей по добросовестному освоению образовательной программы и выполнению учебного плана":
|
||
info = $"Отчисление студента {student} из группы {studentGroupFrom} за неуспеваемость";
|
||
return OrderStudentMoveType.ОтчислитьЗаНеуспевамость;
|
||
case "в связи с переводом в ___":
|
||
info = $"Отчисление студента {student} из группы {studentGroupFrom} в связи с переводом";
|
||
return OrderStudentMoveType.ОтчислитьВСвязиСПереводом;
|
||
default:
|
||
info = string.Empty;
|
||
return OrderStudentMoveType.Неопределено;
|
||
}
|
||
case "Восстановление":
|
||
info = $"Восстановление отчисленного студента {student} в группу {studentGroupTo}";
|
||
return OrderStudentMoveType.Восстановить;
|
||
case "Выпуск":
|
||
info = $"Завершение обучения студента {student}";
|
||
return OrderStudentMoveType.ОтчислитьПоЗавершению;
|
||
default:
|
||
info = string.Empty;
|
||
return OrderStudentMoveType.Неопределено;
|
||
}
|
||
}
|
||
|
||
private void SetYearFinish(StudentViewModel student, StudentGroupViewModel group, OrderViewModel order, OrderStudentMoveType studentOrderType)
|
||
{
|
||
if (student == null)
|
||
{
|
||
return;
|
||
}
|
||
int year = DateTime.Now.Year;
|
||
switch (studentOrderType)
|
||
{
|
||
// у студента не меняется год зачисления
|
||
case OrderStudentMoveType.ПродлитьАкадем:
|
||
case OrderStudentMoveType.ОтчислитьПоЗавершению:
|
||
return;
|
||
// студент уходит с текущего года обучения, сбрасываем его
|
||
case OrderStudentMoveType.Неопределено:
|
||
case OrderStudentMoveType.ОтправитьВАкадем:
|
||
case OrderStudentMoveType.ОтчислитьВСвязиСПереводом:
|
||
case OrderStudentMoveType.ОтчислитьЗаНевыходСАкадема:
|
||
case OrderStudentMoveType.ОтчислитьЗаНеуспевамость:
|
||
case OrderStudentMoveType.ОтчислитьПоСобственному:
|
||
case OrderStudentMoveType.УбратьПоПереводу:
|
||
student.EnrollmentYearId = null;
|
||
return;
|
||
// проблема с разными направлениями групп на разных курсах
|
||
case OrderStudentMoveType.ПеревестиНаСтаршийКурс:
|
||
if (student.EnrollmentYearId.HasValue)
|
||
{
|
||
return;
|
||
}
|
||
if (group == null || order == null)
|
||
{
|
||
return;
|
||
}
|
||
year = order.OrderDate.Year;
|
||
switch (group.AcademicCourse)
|
||
{
|
||
case AcademicCourse.Курс_1:
|
||
break;
|
||
case AcademicCourse.Курс_2:
|
||
year--;
|
||
break;
|
||
case AcademicCourse.Курс_3:
|
||
year -= 2;
|
||
break;
|
||
case AcademicCourse.Курс_4:
|
||
year -= 3;
|
||
break;
|
||
}
|
||
break;
|
||
// может быть зачисление проводилось без указания группы, тогда группа определится при распределении
|
||
case OrderStudentMoveType.Распределить:
|
||
if (student.EnrollmentYearId.HasValue)
|
||
{
|
||
return;
|
||
}
|
||
if (group == null || order == null)
|
||
{
|
||
return;
|
||
}
|
||
year = order.OrderDate.Year;
|
||
break;
|
||
case OrderStudentMoveType.ЗачислитьПоПриказу:
|
||
if (group == null || order == null)
|
||
{
|
||
return;
|
||
}
|
||
year = order.OrderDate.Year;
|
||
break;
|
||
case OrderStudentMoveType.ПринятьПоПереводу:
|
||
case OrderStudentMoveType.ПринятьПоПереводусДругогоВуза:
|
||
case OrderStudentMoveType.Восстановить:
|
||
case OrderStudentMoveType.ВосстановитьИзАкадема:
|
||
case OrderStudentMoveType.ПеревестиНаДругоеНаправлениеКафедры:
|
||
if (group == null || order == null)
|
||
{
|
||
return;
|
||
}
|
||
year = order.OrderDate.Month < 8 ? order.OrderDate.Year - 1 : order.OrderDate.Year;
|
||
switch (group.AcademicCourse)
|
||
{
|
||
case AcademicCourse.Курс_1:
|
||
break;
|
||
case AcademicCourse.Курс_2:
|
||
year--;
|
||
break;
|
||
case AcademicCourse.Курс_3:
|
||
year -= 2;
|
||
break;
|
||
case AcademicCourse.Курс_4:
|
||
year -= 3;
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
|
||
var logic = DependencyManager.Instance.Resolve<IEnrollmentYearLogic>();
|
||
var yearEnrollment = logic.GetElement(new EnrollmentYearGetBindingModel { EducationDirectionId = group.EducationDirectionId, Year = year });
|
||
if (yearEnrollment == null)
|
||
{
|
||
SaveErrors(logic.Errors, "Ошибка установки года выпуска студента", $"Не удалось найти год выпуска студента {student.LastName} {student.FirstName} {student.Patronymic}");
|
||
return;
|
||
}
|
||
|
||
student.EnrollmentYearId = yearEnrollment.Id;
|
||
}
|
||
|
||
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)));
|
||
}
|
||
|
||
private void SaveLog(string info)
|
||
{
|
||
_recordLogic.Create(new OrderSyncHistoryRecordSetBindingModel
|
||
{
|
||
OrderSyncHistoryId = _history.Id,
|
||
Information = info
|
||
});
|
||
}
|
||
}
|
||
} |