< Summary

Information
Class: OzonRepositories.Data.OrderCartRepository
Assembly: OzonRepositories
File(s): /home/runner/work/Studio2Prod/Studio2Prod/OzonRepositories/Data/OrderCartRepository.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 108
Coverable lines: 108
Total lines: 205
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 38
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%210%
Add()0%110100%
Delete()100%210%
DeleteAsync()0%620%
DeleteByOrder()100%210%
DeleteByOrderIds()0%4260%
Get()0%7280%
GetItemId()100%210%
GetWithPagination()0%7280%
GetAsync()100%210%
GetAsync()100%210%
Update()100%210%
GetTotalCount()100%210%

File(s)

/home/runner/work/Studio2Prod/Studio2Prod/OzonRepositories/Data/OrderCartRepository.cs

#LineLine coverage
 1using Microsoft.EntityFrameworkCore;
 2using OzonDomains.Models;
 3using OzonDomains.Models.OrderCarts;
 4using OzonRepositories.Context;
 5
 6namespace OzonRepositories.Data
 7{
 8    public class OrderCartRepository : MainRepository, IRepository<OrderCart>
 9    {
 10        private readonly OrderRepository _orderRepository;
 11
 012        public OrderCartRepository(ApplicationDbContext orderContext, OrderRepository orderRepository) : base(orderConte
 13        {
 014            _orderRepository = orderRepository;
 015        }
 16
 17        public async Task<int> Add(OrderCart cart)
 18        {
 019            if (cart.CartStatus != null)
 20            {
 021                var existingCartStatus = await _context.CartStatuses
 022                    .FirstOrDefaultAsync(cs => cs.Name == cart.CartStatus.Name);
 23
 024                if (existingCartStatus == null)
 25                {
 026                    _context.CartStatuses.Add(cart.CartStatus);
 27                }
 28                else
 29                {
 030                    cart.CartStatus = existingCartStatus;
 31                }
 32            }
 33
 034            foreach (var item in cart.OrderItems)
 35            {
 036                if (item.ItemStatus != null)
 37                {
 038                    var existingItemStatus = await _context.ItemStatuses
 039                        .FirstOrDefaultAsync(ist => ist.Name == item.ItemStatus.Name);
 40
 041                    if (existingItemStatus == null)
 42                    {
 043                        _context.ItemStatuses.Add(item.ItemStatus);
 44                    }
 45                    else
 46                    {
 047                        item.ItemStatus = existingItemStatus;
 48                    }
 49                }
 50
 051                item.OrderCart = cart;
 052            }
 53
 054            _context.OrderCarts.Add(cart);
 055            return await _context.SaveChangesAsync();
 056        }
 57
 58        public async Task<int> Delete(OrderCart cart)
 59        {
 060            _context.OrderCarts.Remove(cart);
 061            return await _context.SaveChangesAsync();
 062        }
 63
 64        public async Task<int> DeleteAsync(int id)
 65        {
 066            var cart = await _context.OrderCarts
 067                .Include(c => c.OrderItems)
 068                .ThenInclude(oi => oi.StudioOrder)
 069                .FirstOrDefaultAsync(c => c.Id == id);
 70
 071            if (cart == null)
 072                return 0;
 73
 074            _context.OrderCarts.Remove(cart);
 075            return await _context.SaveChangesAsync();
 076        }
 77
 78        public async Task<int> DeleteByOrder(int orderId)
 79        {
 080            var cartsToDelete = await _context.OrderItems.Where(c => c.StudioOrderId == orderId).ToListAsync();
 081            _context.OrderItems.RemoveRange(cartsToDelete);
 082            return await _context.SaveChangesAsync();
 083        }
 84
 85        /// <summary>
 86        /// Удаляет элементы корзины для нескольких заказов одним запросом (ускорение страницы транзакций).
 87        /// </summary>
 88        public async Task<int> DeleteByOrderIds(int[] orderIds)
 89        {
 090            if (orderIds == null || orderIds.Length == 0)
 091                return 0;
 92
 093            var distinctIds = orderIds.Distinct().ToArray();
 094            var itemsToDelete = await _context.OrderItems
 095                .Where(oi => oi.StudioOrderId != null && distinctIds.Contains(oi.StudioOrderId.Value))
 096                .ToListAsync();
 097            if (itemsToDelete.Count == 0)
 098                return 0;
 099            _context.OrderItems.RemoveRange(itemsToDelete);
 0100            return await _context.SaveChangesAsync();
 0101        }
 102
 103        public async Task<List<OrderCart>> Get()
 104        {
 0105            var carts = await _context.OrderCarts
 0106                .Include(c => c.CartStatus)
 0107                .Include(c => c.OrderItems)
 0108                .ThenInclude(oi => oi.ItemStatus)
 0109                .ToListAsync();
 110
 111            // Удаляем carts без OrderItems
 0112            var emptyCarts = carts.Where(c => c.OrderItems == null || !c.OrderItems.Any()).ToList();
 0113            if (emptyCarts.Any())
 114            {
 0115                _context.OrderCarts.RemoveRange(emptyCarts);
 0116                await _context.SaveChangesAsync();
 117
 118                // Удаляем их из списка перед возвратом
 0119                carts = carts.Except(emptyCarts).ToList();
 120            }
 121
 0122            foreach (var cart in carts)
 123            {
 0124                foreach (var item in cart.OrderItems)
 125                {
 0126                    if (item.StudioOrderId.HasValue)
 0127                        item.StudioOrder = await _orderRepository.GetAsync(item.StudioOrderId.Value);
 128                }
 129            }
 130
 0131            return carts;
 0132        }
 133
 134        public async Task<OrderItem?> GetItemId(int itemId)
 135        {
 0136            return await _context.OrderItems
 0137                .FirstOrDefaultAsync(c => c.Id == itemId);
 0138        }
 139
 140        public async Task<List<OrderCart>> GetWithPagination(int skip, int take)
 141        {
 0142            var carts = await _context.OrderCarts
 0143                .Include(c => c.CartStatus)
 0144                .Include(c => c.OrderItems)
 0145                .ThenInclude(oi => oi.ItemStatus)
 0146                .OrderByDescending(c => c.CreatedAt)
 0147                .Skip(skip)
 0148                .Take(take)
 0149                .ToListAsync();
 150
 0151            var emptyCarts = carts.Where(c => c.OrderItems == null || !c.OrderItems.Any()).ToList();
 0152            if (emptyCarts.Any())
 153            {
 0154                _context.OrderCarts.RemoveRange(emptyCarts);
 0155                await _context.SaveChangesAsync();
 0156                carts = carts.Except(emptyCarts).ToList();
 157            }
 158
 0159            foreach (var cart in carts)
 160            {
 0161                foreach (var item in cart.OrderItems)
 162                {
 0163                    if (item.StudioOrderId.HasValue)
 0164                        item.StudioOrder = await _orderRepository.GetAsyncForCart(item.StudioOrderId.Value);
 165                }
 166            }
 167
 0168            return carts;
 0169        }
 170
 171        public async Task<OrderCart?> GetAsync(int id)
 172        {
 0173            return await _context.OrderCarts
 0174                .Include(c => c.CartStatus)
 0175                .Include(c => c.OrderItems)
 0176                .ThenInclude(oi => oi.ItemStatus)
 0177                .Include(c => c.OrderItems)
 0178                .ThenInclude(oi => oi.StudioOrder)
 0179                .FirstOrDefaultAsync(c => c.Id == id);
 0180        }
 181
 182        public async Task<OrderCart?> GetAsync(OrderCart value)
 183        {
 0184            return await _context.OrderCarts
 0185                .Include(c => c.CartStatus)
 0186                .Include(c => c.OrderItems)
 0187                .ThenInclude(oi => oi.ItemStatus)
 0188                .Include(c => c.OrderItems)
 0189                .ThenInclude(oi => oi.StudioOrder)
 0190                .FirstOrDefaultAsync(c => c.Id == value.Id);
 0191        }
 192
 193        public async Task<int> Update(OrderCart cart)
 194        {
 0195            _context.OrderCarts.Update(cart);
 0196            return await _context.SaveChangesAsync();
 0197        }
 198
 199        public async Task<int> GetTotalCount()
 200        {
 0201            return await _context.OrderCarts
 0202                .CountAsync(c => c.OrderItems.Any());
 0203        }
 204    }
 205}