Yc.Box.Types.WorkSchedule 1.2.0

Yc.Box.Types.WorkSchedule

Библиотека типов для работы с расписанием работы в проектах YC. Предоставляет полный набор моделей и перечислений для создания, управления и анализа рабочих расписаний с поддержкой различных типов работы, перерывов и статусов.

🚀 Возможности

• Рабочие расписания - Полная модель расписания работы с метаданными
• Рабочие дни - Детальное представление рабочих дней с перерывами
• Перерывы - Гибкая система перерывов с различными типами
• Типы расписаний - Поддержка различных режимов работы
• Статусы расписаний - Управление жизненным циклом расписаний
• Автоматические вычисления - Расчет рабочих часов и дней
• Валидация - Проверка корректности расписаний

📦 Установка

dotnet add package Yc.Box.Types.WorkSchedule

🔧 Использование

Создание расписания работы

using Yc.Box.Types.WorkSchedule.Models;
using Yc.Box.Types.WorkSchedule.Enums;

public class WorkScheduleService
{
    public YcWorkSchedule CreateStandardSchedule()
    {
        var schedule = new YcWorkSchedule
        {
            Id = Guid.NewGuid(),
            Name = "Стандартное расписание",
            Description = "Стандартное расписание 5/2 с 9 до 18",
            Type = YcScheduleType.FullTime,
            Status = YcScheduleStatus.Active,
            EffectiveFrom = DateTime.Today,
            WorkDays = new List<YcWorkDay>()
        };

        // Добавляем рабочие дни
        var workDays = new[] { DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday, 
                              DayOfWeek.Thursday, DayOfWeek.Friday };

        foreach (var dayOfWeek in workDays)
        {
            var workDay = CreateWorkDay(dayOfWeek, TimeSpan.FromHours(9), TimeSpan.FromHours(18));
            schedule.WorkDays.Add(workDay);
        }

        return schedule;
    }

    public YcWorkSchedule CreateFlexibleSchedule()
    {
        var schedule = new YcWorkSchedule
        {
            Id = Guid.NewGuid(),
            Name = "Гибкое расписание",
            Description = "Гибкое расписание с возможностью выбора времени",
            Type = YcScheduleType.Flexible,
            Status = YcScheduleStatus.Active,
            WorkDays = new List<YcWorkDay>()
        };

        // Добавляем все дни недели с гибким временем
        for (int i = 0; i < 7; i++)
        {
            var dayOfWeek = (DayOfWeek)i;
            var workDay = CreateFlexibleWorkDay(dayOfWeek);
            schedule.WorkDays.Add(workDay);
        }

        return schedule;
    }

    public YcWorkSchedule CreateShiftSchedule()
    {
        var schedule = new YcWorkSchedule
        {
            Id = Guid.NewGuid(),
            Name = "Сменное расписание",
            Description = "Сменное расписание 12/12",
            Type = YcScheduleType.Shift,
            Status = YcScheduleStatus.Active,
            WorkDays = new List<YcWorkDay>()
        };

        // Дневная смена
        var dayShift = CreateWorkDay(DayOfWeek.Monday, TimeSpan.FromHours(8), TimeSpan.FromHours(20));
        schedule.WorkDays.Add(dayShift);

        // Ночная смена
        var nightShift = CreateWorkDay(DayOfWeek.Tuesday, TimeSpan.FromHours(20), TimeSpan.FromHours(8));
        schedule.WorkDays.Add(nightShift);

        return schedule;
    }
}

Создание рабочих дней

public class WorkDayService
{
    public YcWorkDay CreateWorkDay(DayOfWeek dayOfWeek, TimeSpan startTime, TimeSpan endTime)
    {
        var workDay = new YcWorkDay
        {
            Id = Guid.NewGuid(),
            DayOfWeek = dayOfWeek,
            StartTime = startTime,
            EndTime = endTime,
            IsWorkingDay = true,
            Description = $"Рабочий день - {dayOfWeek}",
            Breaks = new List<YcBreak>()
        };

        // Добавляем обеденный перерыв
        var lunchBreak = CreateBreak(YcBreakType.Lunch, TimeSpan.FromHours(13), TimeSpan.FromHours(1));
        workDay.Breaks.Add(lunchBreak);

        // Добавляем кофе-брейк
        var coffeeBreak = CreateBreak(YcBreakType.CoffeeBreak, TimeSpan.FromHours(15, 30), TimeSpan.FromMinutes(15));
        workDay.Breaks.Add(coffeeBreak);

        return workDay;
    }

    public YcWorkDay CreateFlexibleWorkDay(DayOfWeek dayOfWeek)
    {
        return new YcWorkDay
        {
            Id = Guid.NewGuid(),
            DayOfWeek = dayOfWeek,
            StartTime = TimeSpan.FromHours(8),
            EndTime = TimeSpan.FromHours(20),
            IsWorkingDay = true,
            Description = $"Гибкий рабочий день - {dayOfWeek}",
            Breaks = new List<YcBreak>()
        };
    }

    public YcWorkDay CreateWeekend(DayOfWeek dayOfWeek)
    {
        return new YcWorkDay
        {
            Id = Guid.NewGuid(),
            DayOfWeek = dayOfWeek,
            StartTime = TimeSpan.Zero,
            EndTime = TimeSpan.Zero,
            IsWorkingDay = false,
            Description = $"Выходной - {dayOfWeek}",
            Breaks = new List<YcBreak>()
        };
    }
}

Создание перерывов

public class BreakService
{
    public YcBreak CreateBreak(YcBreakType breakType, TimeSpan startTime, TimeSpan duration)
    {
        return new YcBreak
        {
            Id = Guid.NewGuid(),
            Type = breakType,
            StartTime = startTime,
            Duration = duration,
            Description = GetBreakDescription(breakType),
            IsRequired = IsRequiredBreak(breakType)
        };
    }

    public YcBreak CreateLunchBreak()
    {
        return CreateBreak(YcBreakType.Lunch, TimeSpan.FromHours(13), TimeSpan.FromHours(1));
    }

    public YcBreak CreateCoffeeBreak()
    {
        return CreateBreak(YcBreakType.CoffeeBreak, TimeSpan.FromHours(15, 30), TimeSpan.FromMinutes(15));
    }

    public YcBreak CreateTechnicalBreak()
    {
        return CreateBreak(YcBreakType.TechnicalBreak, TimeSpan.FromHours(11), TimeSpan.FromMinutes(10));
    }

    private string GetBreakDescription(YcBreakType breakType)
    {
        return breakType switch
        {
            YcBreakType.Lunch => "Обеденный перерыв",
            YcBreakType.CoffeeBreak => "Кофе-брейк",
            YcBreakType.TechnicalBreak => "Технический перерыв",
            YcBreakType.RestBreak => "Перерыв на отдых",
            YcBreakType.SmokingBreak => "Перерыв на курение",
            YcBreakType.TrainingBreak => "Перерыв на обучение",
            _ => "Другой перерыв"
        };
    }

    private bool IsRequiredBreak(YcBreakType breakType)
    {
        return breakType switch
        {
            YcBreakType.Lunch => true,
            YcBreakType.TechnicalBreak => true,
            _ => false
        };
    }
}

Анализ расписаний

public class WorkScheduleAnalyzer
{
    public WorkScheduleAnalysis AnalyzeSchedule(YcWorkSchedule schedule)
    {
        return new WorkScheduleAnalysis
        {
            TotalWorkHours = schedule.WeeklyWorkHours,
            WorkingDaysCount = schedule.WorkingDaysCount,
            IsActive = schedule.IsActive,
            IsEffective = schedule.IsEffective,
            AverageWorkHoursPerDay = schedule.WorkingDaysCount > 0 
                ? schedule.WeeklyWorkHours / schedule.WorkingDaysCount 
                : TimeSpan.Zero
        };
    }

    public List<YcWorkDay> GetWorkingDays(YcWorkSchedule schedule)
    {
        return schedule.WorkDays.Where(wd => wd.IsWorkingDay).ToList();
    }

    public List<YcWorkDay> GetNonWorkingDays(YcWorkSchedule schedule)
    {
        return schedule.WorkDays.Where(wd => !wd.IsWorkingDay).ToList();
    }

    public TimeSpan GetTotalBreakTime(YcWorkSchedule schedule)
    {
        return TimeSpan.FromTicks(schedule.WorkDays.Sum(wd => wd.TotalBreakDuration.Ticks));
    }

    public TimeSpan GetNetWorkTime(YcWorkSchedule schedule)
    {
        return schedule.WeeklyWorkHours - GetTotalBreakTime(schedule);
    }

    public bool IsValidSchedule(YcWorkSchedule schedule)
    {
        if (schedule.WorkDays == null || !schedule.WorkDays.Any())
            return false;

        foreach (var workDay in schedule.WorkDays)
        {
            if (workDay.StartTime >= workDay.EndTime)
                return false;

            foreach (var break_ in workDay.Breaks)
            {
                if (break_.StartTime < workDay.StartTime || 
                    break_.EndTime > workDay.EndTime)
                    return false;
            }
        }

        return true;
    }
}

public class WorkScheduleAnalysis
{
    public TimeSpan TotalWorkHours { get; set; }
    public int WorkingDaysCount { get; set; }
    public bool IsActive { get; set; }
    public bool IsEffective { get; set; }
    public TimeSpan AverageWorkHoursPerDay { get; set; }
}

API контроллер для расписаний

using Yc.Box.Types.WorkSchedule.Models;
using Yc.Box.Types.WorkSchedule.Enums;
using Yc.Box.Types.Core.Models.ApiResponses;

[ApiController]
[Route("api/[controller]")]
public class WorkSchedulesController : ControllerBase
{
    private readonly WorkScheduleService _workScheduleService;
    private readonly WorkScheduleAnalyzer _analyzer;

    public WorkSchedulesController(WorkScheduleService workScheduleService, WorkScheduleAnalyzer analyzer)
    {
        _workScheduleService = workScheduleService;
        _analyzer = analyzer;
    }

    [HttpGet]
    public ActionResult<YcApiResponse<List<YcWorkSchedule>>> GetWorkSchedules()
    {
        var schedules = _workScheduleService.GetAllSchedules();
        return this.SuccessResponse(schedules, "Расписания получены");
    }

    [HttpGet("{id}")]
    public ActionResult<YcApiResponse<YcWorkSchedule>> GetWorkSchedule(Guid id)
    {
        var schedule = _workScheduleService.GetById(id);
        if (schedule == null)
            return this.NotFoundError($"Расписание с ID {id} не найдено");

        return this.SuccessResponse(schedule);
    }

    [HttpGet("{id}/analysis")]
    public ActionResult<YcApiResponse<WorkScheduleAnalysis>> AnalyzeWorkSchedule(Guid id)
    {
        var schedule = _workScheduleService.GetById(id);
        if (schedule == null)
            return this.NotFoundError($"Расписание с ID {id} не найдено");

        var analysis = _analyzer.AnalyzeSchedule(schedule);
        return this.SuccessResponse(analysis, "Анализ расписания выполнен");
    }

    [HttpPost]
    public ActionResult<YcApiResponse<YcWorkSchedule>> CreateWorkSchedule([FromBody] CreateWorkScheduleRequest request)
    {
        if (!ModelState.IsValid)
            return this.ValidationError();

        var schedule = _workScheduleService.CreateSchedule(request);
        
        if (!_analyzer.IsValidSchedule(schedule))
            return this.ValidationError("Расписание содержит некорректные данные");

        return this.SuccessResponse(schedule, "Расписание создано");
    }

    [HttpPut("{id}/status")]
    public ActionResult<YcApiResponse> UpdateScheduleStatus(Guid id, [FromBody] YcScheduleStatus status)
    {
        var schedule = _workScheduleService.GetById(id);
        if (schedule == null)
            return this.NotFoundError($"Расписание с ID {id} не найдено");

        schedule.Status = status;
        schedule.UpdatedAt = DateTime.UtcNow;

        return this.SuccessResponse("Статус расписания обновлен");
    }
}

📋 Доступные перечисления

YcScheduleType

• FullTime - Полный рабочий день
• PartTime - Неполный рабочий день
• Shift - Сменное расписание
• Flexible - Гибкое расписание
• Remote - Удаленная работа
• Temporary - Временное расписание
• Seasonal - Сезонное расписание
• Other - Другой тип

YcScheduleStatus

• Draft - Черновик
• Active - Активное
• Suspended - Приостановлено
• Completed - Завершено
• Cancelled - Отменено
• Archived - Архивное

YcBreakType

• Lunch - Обед
• CoffeeBreak - Кофе-брейк
• TechnicalBreak - Технический перерыв
• RestBreak - Перерыв на отдых
• SmokingBreak - Перерыв на курение
• TrainingBreak - Перерыв на обучение
• Other - Другой тип перерыва

🏗️ Структура пакета

Yc.Box.Types.WorkSchedule/
├── Models/
│   ├── YcWorkSchedule.cs              # Основная модель расписания
│   ├── YcWorkDay.cs                   # Модель рабочего дня
│   └── YcBreak.cs                     # Модель перерыва
└── Enums/
    ├── YcScheduleType.cs              # Типы расписаний
    ├── YcScheduleStatus.cs            # Статусы расписаний
    └── YcBreakType.cs                 # Типы перерывов

🔒 Совместимость

• .NET 9.0+
• Все классы имеют префикс Yc для избежания конфликтов имен

📄 Лицензия

Проект YC Team

🤝 Поддержка

Для вопросов и предложений обращайтесь к команде разработки YC.

📈 Версии

• 1.0.0 - Первоначальный релиз с моделями расписания
• 1.1.0 - Добавлены вычисляемые свойства и валидация
• 1.2.0 - Переименование классов с префиксом Yc