API/src/Model2Entities/ActivityRepository.cs

using Model;
using Model.Repository;
using Shared;
using Model.Manager;
using Microsoft.Extensions.Logging;
using Entities;
using EFMappers;
using Microsoft.EntityFrameworkCore;

namespace Model2Entities;

public partial class DbDataManager : IDataManager
{
    public class ActivityRepository : IActivityRepository
    {
        private readonly DbDataManager _dataManager;
        private readonly ILogger<ActivityRepository> _logger = new Logger<ActivityRepository>(new LoggerFactory());
        
        // logger et tests sur tout et mapper
        public ActivityRepository(DbDataManager dataManager)
        {
            _dataManager = dataManager;
            // _logger = logger;
        }

        public async Task<IEnumerable<Activity>> GetActivities(int index, int count, ActivityOrderCriteria criteria, bool descending = false)
        {
            _logger.LogInformation($"GetActivities with index {index} and count {count}", index, count);
            _logger.LogInformation($"GetActivities with criteria {criteria} and descending {descending}", criteria, descending);
            
            var activities = _dataManager.DbContext.ActivitiesSet.GetItemsWithFilterAndOrdering(b => true, index, count, criteria, descending).ToModels();
            
            _logger.LogInformation($"Retrieved {activities.Count()} activities");
            return await Task.FromResult(activities);
        }

        public async Task<Activity?> GetActivityByIdAsync(int id)
        {
            _logger.LogInformation($"GetActivityByIdAsync with id {id}", id);
            // ! By None don't pass the filter
            var activity = _dataManager.DbContext.ActivitiesSet.GetItemsWithFilterAndOrdering(b => b.IdActivity == id, 0, 1, ActivityOrderCriteria.None, false).First().ToModel();

            if (activity != null)
                _logger.LogInformation($"Retrieved activity with ID {id}");
            else
                _logger.LogWarning($"No activity found with ID {id}");

            return await Task.FromResult(activity);
        }

        public async Task<Activity?> AddActivity(Activity activity)
        {
            try
            {
                _logger.LogInformation("Adding new activity");
                var addedActivity =  (await _dataManager.DbContext.AddItem(activity.ToEntity())).ToModel();
                if (addedActivity != null)
                    _logger.LogInformation($"Added activity with ID {addedActivity.Id}");
                else
                    _logger.LogError("Failed to add activity");
                return await Task.FromResult(addedActivity);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error occurred while adding activity");
                throw;
            }
        }

        public async Task<Activity?> UpdateActivity(int id, Activity activity)
        {
            try
            {
                return activity;
                // _logger.LogInformation($"Updating activity with ID {id}");
                // var updatedActivity = await _dataManager.DbContext.ActivitiesSet.UpdateItem<ActivityEntity>(_dataManager.DbContext,(await GetActivityByIdAsync(id)).ToEntity(), activity.ToEntity());
                // if (updatedActivity != null)
                //     _logger.LogInformation($"Updated activity with ID {id}");
                // else
                //     _logger.LogError($"Failed to update activity with ID {id}");
                // return await Task.FromResult(updatedActivity.ToModel());
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"Error occurred while updating activity with ID {id}");
                throw;
            }
        }

        public async Task<bool> DeleteActivity(int id)
        {
            try
            {
                _logger.LogInformation($"Deleting activity with ID {id}");
                var isDeleted = await _dataManager.DbContext.DeleteItem<ActivityEntity>(id);
                if (isDeleted)
                    _logger.LogInformation($"Deleted activity with ID {id}");
                else
                    _logger.LogWarning($"No activity found with ID {id}");
                return await Task.FromResult(isDeleted);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"Error occurred while deleting activity with ID {id}");
                throw;
            }
        }

        public async Task<int> GetNbItems()
        {
            try
            {
                _logger.LogInformation("Getting the total number of activities");
                var count = await _dataManager.DbContext.ActivitiesSet.CountAsync();
                _logger.LogInformation($"Total number of activities: {count}");
                return await Task.FromResult(count);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error occurred while getting the total number of activities");
                throw;
            }
        }

        public Task<IEnumerable<Activity>> GetActivitiesByUser(int userId, int index, int count, ActivityOrderCriteria criteria, bool descending = false)
        {
            throw new NotImplementedException();
        }

        public Task<int> GetNbActivitiesByUser(int userId)
        {
            throw new NotImplementedException();
        }
    }
}