UserService/UserService.DatabaseLayer/Repositories/UsersRepository.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks;
using LinqToDB;
using UserService.DatabaseLayer.DataModels;
using UserService.Infrastructure.DataModels;

namespace UserService.DatabaseLayer.Repositories
{
    public class UsersRepository : BaseRepository, IUsersRepository
    {
        /// <inheritdoc />
        public async Task<IReadOnlyList<User>> GetAllAsync(Expression<Func<NodeModel, bool>>? predicate = null,
            CancellationToken token = default)
        {
            await using var db = new UserService2DB();
            var users = await db.NodeModels
                .LoadWith(x => x.Parent)
                .Where(x => x.Discriminator == nameof(User))
                .WhereOrDefault(predicate)
                .Select(x => new User
                {
                    Id = x.Id,
                    CommonName = x.CommonName,
                    Description = x.Description,
                    FirstName = x.FirstName,
                    LastName = x.LastName,
                    IsActive = x.IsActive ?? false,
                    EMail = x.EMail,
                    ParentId = x.ParentId,
                })
                .ToListAsync(token).ConfigureAwait(false);
            return users;
        }

        /// <inheritdoc />
        public async Task<User?> GetAsync(Expression<Func<NodeModel, bool>> predicate,
            CancellationToken token = default)
        {
            await using var db = new UserService2DB();
            var result = await db.NodeModels
                .Where(predicate)
                .Select(x => new User
                {
                    Id = x.Id,
                    CommonName = x.CommonName,
                    Description = x.Description,
                    FirstName = x.FirstName,
                    LastName = x.LastName,
                    IsActive = x.IsActive ?? false,
                    EMail = x.EMail
                }).FirstOrDefaultAsync(token).ConfigureAwait(false);
            return result;
        }

        /// <inheritdoc />
        public async Task<int> AddAsync(User entity, CancellationToken token = default)
        {
            await using var db = new UserService2DB();

            return await db.NodeModels.InsertWithInt32IdentityAsync(() => new NodeModel
            {
                CommonName = entity.CommonName,
                FirstName = entity.FirstName,
                LastName = entity.LastName,
                Description = entity.Description,
                EMail = entity.EMail,
                IsActive = entity.IsActive,
                Discriminator = nameof(User),
            }, token).ConfigureAwait(false);
        }

        /// <inheritdoc />
        public async Task<bool> UpdateAsync(User entity, CancellationToken token = default)
        {
            await using var db = new UserService2DB();

            var changedRows = await db.NodeModels.UpdateAsync(x => new NodeModel
            {
                Id = entity.Id,
                CommonName = entity.CommonName,
                FirstName = entity.FirstName,
                LastName = entity.LastName,
                Description = entity.Description,
                EMail = entity.EMail,
                IsActive = entity.IsActive,
                Discriminator = nameof(User),
            }, token).ConfigureAwait(false);
            return changedRows > 0;
        }

        /// <inheritdoc />
        public async Task DeleteAsync(User entity, CancellationToken token = default)
        {
            await using var db = new UserService2DB();
            await db.NodeModels.DeleteAsync(x => x.Id == entity.Id, token).ConfigureAwait(false);
        }
    }
}