gehgassi_backend/gehGassi.Core/Services/CustomerService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using gehGassi.Core.Interfaces;
using gehGassi.Domain.Common;
using gehGassi.Domain.Customers;

namespace gehGassi.Core.Services
{
    /// <summary>
    /// Service der die Verwaltung von Kunden realisiert
    /// </summary>
    public class CustomerService : ServiceBase<Customer>, ICustomerService
    {
        private readonly IRepository<CustomerWithNames> _customerWithNamesRepository;

        public CustomerService(IUnitOfWork unitOfWork) : base(unitOfWork)
        {
            _customerWithNamesRepository = unitOfWork.GetRepository<CustomerWithNames>();
        }

        /// <summary>
        /// Gibt eine gefilterte Liste von Kunden zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Kunden</returns>
        public IQueryable<Customer> Filter(string filter)
        {
            return Repository.Query(c => c.Name.Contains(filter) || c.Number.Contains(filter) || c.Comment.Contains(filter));
        }

        /// <summary>
        /// Erstellen eines Kunden
        /// </summary>
        /// <returns>Kunde</returns>
        public Customer Create()
        {
            var item = new Customer
            {
                Contact = new Contact(),
                Address = new Address(),
                UniqueId = Guid.NewGuid()
            };
            return item;
        }

        /// <summary>
        /// Gibt eine gefilterte Liste von Kunden zurück. Sucht nur im Namen
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Kunden</returns>
        public async Task<List<Customer>> SearchAsync(string filter)
        {
            return (await Repository.FindAsync(c => c.Name.Contains(filter))).ToList();
        }

        /// <summary>
        /// Gibt eine gefilterte Liste von Kunden zurück die ein Mangopay Konto haben. Sucht nur im Namen
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <returns>List betroffener Kunden</returns>
        public async Task<List<Customer>> SearchWithMangopayAccountAsync(string filter)
        {
            return (await Repository.FindAsync(c => c.Name.Contains(filter) && c.MangopayIdCreated)).ToList();
        }

        /// <summary>
        /// Gibt ein Kunden zurück
        /// </summary>
        /// <param name="uniqueId">UniqueId des Kunden</param>
        /// <returns>Betroffener Kunde</returns>
        public async Task<Customer> GetByUniqueIdAsync(Guid uniqueId)
        {
            return await Repository.FirstOrDefaultAsync(c => c.UniqueId == uniqueId).ConfigureAwait(false);
        }

        /// <summary>
        /// Gibt eine gefilterte Liste von Kunden mit Namen zurück
        /// </summary>
        /// <param name="filter">Filterbegriff der in bestimmten Feldern gesucht wird</param>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="fallback">Fallback Sprache</param>
        /// <returns>List betroffener Kunden</returns>
        public IQueryable<CustomerWithNames> FilterWithNames(string filter, string language, string fallback)
        {
            language = language.ToUpperInvariant();
            fallback = fallback.ToUpperInvariant();

            var baseQuery = _customerWithNamesRepository.QueryStoredProcedure("SELECT * FROM tv_CustomersWithNames({0},{1})", c => c.Name.Contains(filter) || c.Number.Contains(filter), language, fallback);
            return baseQuery;
        }

        /// <summary>
        /// Gibt die nächste freie Nummer für einen Kunden zurück
        /// </summary>
        /// <returns>Kunden-Nummer</returns>
        public string GetNextNumber()
        {
            long number = 1;
            var last = Repository.Query(c => c.Id != -1).OrderByDescending(c => c.Id).FirstOrDefault();
            if (last != null)
                number = last.Id + 1;
            return $"K-{DateTime.UtcNow.Year:0000}{DateTime.UtcNow.Month:00}-{number:00000}";
        }

        /// <summary>
        /// Zurücksetzen des Kunden-Typs auf null
        /// </summary>
        /// <param name="typeId">Id des Kunden-Typs</param>
        /// <returns>Anzahl zurückgesetzte Kunden</returns>
        public async Task<int> ResetTypeAsync(long typeId)
        {
            var items = (await Repository.FindAsync(c => c.TypeId == typeId).ConfigureAwait(false)).ToList();
            foreach (var item in items)
            {
                item.TypeId = null;
            }

            return items.Count;
        }

        /// <summary>
        /// Zurücksetzen der Branche auf null
        /// </summary>
        /// <param name="branchId">Id der Branche</param>
        /// <returns>Anzahl zurückgesetzte Kunden</returns>
        public async Task<int> ResetBranchAsync(string branchId)
        {
            var items = (await Repository.FindAsync(c => c.BranchId == branchId).ConfigureAwait(false)).ToList();
            foreach (var item in items)
            {
                item.TypeId = null;
            }

            return items.Count;
        }

        /// <summary>
        /// Zurücksetzen der Branchen-Listungen
        /// </summary>
        /// <param name="branchId">Id der Branche</param>
        /// <returns>Anzahl zurückgesetzte Kunden</returns>
        public async Task<int> ResetBranchListingsAsync(string branchId)
        {
            var items = (await Repository.FindAsync(c => c.BranchesJson.Contains(branchId)).ConfigureAwait(false)).ToList();
            foreach (var customer in items)
            {
                var branches = customer.BranchesJson.Split(',').ToList();
                branches.Remove(branchId);
                customer.BranchesJson = string.Join(',', branches);
            }

            return items.Count;
        }
    }
}