marco.pms.api/Marco.Pms.Services/Helpers/DirectoryHelper.cs

using Marco.Pms.DataAccess.Data;
using Marco.Pms.Model.Directory;
using Marco.Pms.Model.Dtos.Directory;
using Marco.Pms.Model.Mapper;
using Marco.Pms.Model.Utilities;
using Marco.Pms.Model.ViewModels.Directory;
using Marco.Pms.Model.ViewModels.Master;
using MarcoBMS.Services.Helpers;
using MarcoBMS.Services.Service;
using Microsoft.EntityFrameworkCore;

namespace Marco.Pms.Services.Helpers
{
    public class DirectoryHelper
    {
        private readonly ApplicationDbContext _context;
        private readonly ILoggingService _logger;
        private readonly UserHelper _userHelper;


        public DirectoryHelper(ApplicationDbContext context, ILoggingService logger, UserHelper userHelper)
        {
            _context = context;
            _logger = logger;
            _userHelper = userHelper;
        }



        public async Task<ApiResponse<object>> GetListOfContacts()
        {
            Guid tenantId = _userHelper.GetTenantId();
            var LoggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();

            var contacts = await _context.Contacts.Where(c => c.TenantId == tenantId).ToListAsync();
            List<Guid> contactIds = contacts.Select(c => c.Id).ToList();

            var phoneNo = await _context.ContactsPhones.Where(p => contactIds.Contains(p.ContactId)).ToListAsync();
            var Emails = await _context.ContactsEmails.Where(E => contactIds.Contains(E.ContactId)).ToListAsync();
            var Tags = await _context.ContactTagMappings.Where(t => contactIds.Contains(t.ContactId)).ToListAsync();
            List<Guid> TagIds = Tags.Select(t => t.ContactTagtId).ToList();

            var TagList = await _context.ContactTagMasters.Where(t => TagIds.Contains(t.Id)).ToListAsync();

            List<ContactVM> list = new List<ContactVM>();

            foreach (var contact in contacts)
            {

                ContactVM contactVM = new ContactVM();
                List<ContactEmailVM> contactEmailVms = new List<ContactEmailVM>();
                List<ContactPhoneVM> contactPhoneVms = new List<ContactPhoneVM>();

                List<ContactTagVM> conatctTagVms = new List<ContactTagVM>();
                var phones = phoneNo.Where(p => p.ContactId == contact.Id).ToList();
                var emails = Emails.Where(e => e.ContactId == contact.Id).ToList();
                var tagMappingss = Tags.Where(t => t.ContactId == contact.Id).ToList();


                if (emails != null)
                {
                    foreach (var email in emails)
                    {
                        ContactEmailVM emailVM = new ContactEmailVM();
                        emailVM = email.ToContactEmailVMFromContactEmail();
                        contactEmailVms.Add(emailVM);
                    }
                }

                if (phones != null)
                {
                    foreach (var phone in phones)
                    {
                        ContactPhoneVM phoneVM = new ContactPhoneVM();
                        phoneVM = phone.ToContactPhoneVMFromContactPhone();
                        contactPhoneVms.Add(phoneVM);
                    }

                }
                if (tagMappingss != null)
                {
                    foreach (var tagMapping in tagMappingss)
                    {
                        ContactTagVM tagVM = new ContactTagVM(); ;
                        var tag = TagList.Find(t => t.Id == tagMapping.ContactTagtId);

                        tagVM = tag != null ? tag.ToContactTagVMFromContactTagMaster() : new ContactTagVM();
                        conatctTagVms.Add(tagVM);


                    }
                }


                contactVM = contact.ToContactVMFromContact();
                contactVM.ContactEmails = contactEmailVms;
                contactVM.ContactPhones = contactPhoneVms;
                contactVM.Tags = conatctTagVms;

                list.Add(contactVM);
            }
            _logger.LogInfo("{count} contacts are fetched by Employee with ID {LoggedInEmployeeId}", list.Count, LoggedInEmployee.Id);
            return ApiResponse<object>.SuccessResponse(list, System.String.Format("{0} contacts fetched successfully", list.Count), 200);

        }

        public async Task<ApiResponse<object>> CreateContact(CreateContactDto createContact)
        {
            Guid tenantId = _userHelper.GetTenantId();
            var LoggedInEmployee = await _userHelper.GetCurrentEmployeeAsync();
            if (createContact != null)
            {
                List<ContactPhone> phones = new List<ContactPhone>();
                List<ContactEmail> emails = new List<ContactEmail>();
                List<ContactBucketMapping> contactBucketMappings = new List<ContactBucketMapping>();
                List<ContactTagMapping> contactTagMappings = new List<ContactTagMapping>();

                Contact? contact = createContact.ToContactFromCreateContactDto(tenantId, LoggedInEmployee.Id);

                _context.Contacts.Add(contact);
                await _context.SaveChangesAsync();
                _logger.LogInfo("Contact with ID {ContactId} created by Employee with ID {LoggedInEmployeeId}", contact.Id, LoggedInEmployee.Id);

                var tags = await _context.ContactTagMasters.Where(t => t.TenantId == tenantId).ToListAsync();
                var buckets = await _context.Buckets.Where(b => b.TenantId == tenantId).Select(b => b.Id).ToListAsync();
                if (createContact.ContactPhones != null)
                {

                    foreach (var contactPhone in createContact.ContactPhones)
                    {
                        ContactPhone phone = contactPhone.ToContactPhoneFromCreateContactPhoneDto(tenantId, contact.Id);
                        phones.Add(phone);
                    }
                    _context.ContactsPhones.AddRange(phones);
                    _logger.LogInfo("{count} phone number are saved in contact with ID {ContactId} by employee with ID {LoggedEmployeeId}", phones.Count, contact.Id, LoggedInEmployee.Id);
                }
                if (createContact.ContactEmails != null)
                {

                    foreach (var contactEmail in createContact.ContactEmails)
                    {
                        ContactEmail email = contactEmail.ToContactEmailFromCreateContactEmailDto(tenantId, contact.Id);
                        emails.Add(email);
                    }
                    _context.ContactsEmails.AddRange(emails);
                    _logger.LogInfo("{count} email addresses are saved in contact with ID {ContactId} by employee with ID {LoggedEmployeeId}", emails.Count, contact.Id, LoggedInEmployee.Id);
                }
                if (createContact.BucketIds != null)
                {
                    foreach (var bucket in createContact.BucketIds)
                    {
                        if (buckets.Contains(bucket))
                        {
                            ContactBucketMapping bucketMapping = new ContactBucketMapping
                            {
                                BucketId = bucket,
                                ContactId = contact.Id
                            };
                            contactBucketMappings.Add(bucketMapping);
                        }
                    }
                    _context.ContactBucketMappings.AddRange(contactBucketMappings);
                    _logger.LogInfo("Contact with ID {ContactId} added to {count} number of buckets by employee with ID {LoggedEmployeeId}", contact.Id, LoggedInEmployee.Id);
                }
                if (createContact.TagIds != null)
                {
                    foreach (var tag in createContact.TagIds)
                    {
                        if (tags.Where(t => t.Id == tag) != null)
                        {
                            ContactTagMapping tagMapping = new ContactTagMapping
                            {
                                ContactTagtId = tag,
                                ContactId = contact.Id
                            };
                        }
                    }
                    _context.ContactTagMappings.AddRange(contactTagMappings);
                }
                await _context.SaveChangesAsync();

                ContactVM contactVM = new ContactVM();
                List<ContactPhoneVM> phoneVMs = new List<ContactPhoneVM>();
                foreach (var phone in phones)
                {
                    ContactPhoneVM phoneVM = phone.ToContactPhoneVMFromContactPhone();
                    phoneVMs.Add(phoneVM);
                }
                List<ContactEmailVM> emailVMs = new List<ContactEmailVM>();
                foreach (var email in emails)
                {
                    ContactEmailVM emailVM = email.ToContactEmailVMFromContactEmail();
                    emailVMs.Add(emailVM);
                }
                List<ContactTagVM> tagVMs = new List<ContactTagVM>();
                foreach (var contactTagMapping in contactTagMappings)
                {
                    ContactTagVM tagVM = new ContactTagVM();
                    var tag = tags.Find(t => t.Id == contactTagMapping.ContactTagtId);
                    tagVM = tag != null ? tag.ToContactTagVMFromContactTagMaster() : new ContactTagVM();
                    tagVMs.Add(tagVM);
                }


                contactVM = contact.ToContactVMFromContact();
                contactVM.ContactPhones = phoneVMs;
                contactVM.ContactEmails = emailVMs;
                contactVM.Tags = tagVMs;

                return ApiResponse<object>.SuccessResponse(contactVM, "Contact Created Successfully", 200);
            }
            _logger.LogWarning("User send empty payload");
            return ApiResponse<object>.ErrorResponse("User send empty data", "User send empty data", 400);
        }
    }
}