monorepo/LCU.API.Internal.Dispatcher/LCU.Api.Internal.DispatcherLib/Repositories/WorkItemRepository.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using LCU.Api.Internal.DispatcherLib.Persistence;
using LCU.Api.Internal.DispatcherLib.Extensions.Queryables;
using LCU.Library.Internal.DispatcherModels.Entities;
namespace LCU.Api.Internal.DispatcherLib.Repositories;

public class WorkItemRepository : BaseRepository, IWorkItemRepository
{
    public WorkItemRepository(AppDbContext context) : base(context) { }

    public async Task<IEnumerable<WorkItem>> ListByJobIdAsync(int jobId)
    {
        return await _context.WorkItems.Where(wi => wi.JobId == jobId)
                                        .IncludeAll()
                                        .AsNoTracking()
                                        .ToListAsync();
    }

    public async Task<IEnumerable<WorkItem>> ListAsync()
    {
        return await _context.WorkItems.IncludeAll()
                                        .AsNoTracking()
                                        .ToListAsync();
    }

    public async Task<WorkItem> FindByIdAsync(int id)
    {
        return await _context.WorkItems.Where(workItem => workItem.WorkItemId == id)
                                        .IncludeAll()
                                        .AsNoTracking()
                                        .FirstOrDefaultAsync();
    }

    public async Task<IEnumerable<WorkItem>> FindByJobIdAsync(int jobId)
    {
        return await _context.WorkItems.Where(workItem => workItem.JobId == jobId)
                                        .AsNoTracking()
                                        .ToListAsync();
    }

    public async Task<IEnumerable<WorkItem>> FindByJobIdWithExecutionsAsync(int jobId, int numberOfWorkItemExecutions, int numberOfExecutionMessages)
    {
        return await _context.WorkItems.Where(workItem => workItem.JobId == jobId)
                                        .IncludeAll(numberOfWorkItemExecutions, numberOfExecutionMessages)
                                        .AsNoTracking()
                                        .ToListAsync();
    }

    public async Task<WorkItem> GetFirstOrDefaultWorkItemByJobId(int jobId)
    {
        return await _context.WorkItems.Where(workItem => workItem.JobId == jobId)
                                        .OrderBy(wi => wi.Order)
                                        .AsNoTracking()
                                        .FirstOrDefaultAsync();
    }

    public async Task<WorkItem> GetNextWorkItemByJobId(int jobId, int currentWorkItemOrder)
    {
        return await _context.WorkItems.Where(workItem => workItem.JobId == jobId && workItem.Order > currentWorkItemOrder)
                                        .OrderBy(wi => wi.Order)
                                        .AsNoTracking()
                                        .FirstOrDefaultAsync();
    }

    public async Task<WorkItem> GetTrackedWorkItem(int workItemId)
    {
        return await _context.WorkItems.FirstAsync(w => w.WorkItemId == workItemId);
    }

    public async Task<WorkItem> AddAsync(WorkItem workItem)
    {
        var result = await _context.WorkItems.AddAsync(workItem);
        return result.Entity;
    }

    public void Update(WorkItem workItem)
    {
        _context.WorkItems.Update(workItem);
    }

    public void AddList(IEnumerable<WorkItem> workItems)
    {
        _context.WorkItems.AddRange(workItems);
    }

    public void RemoveList(IEnumerable<WorkItem> workItems)
    {
        _context.WorkItems.RemoveRange(workItems);
    }
}