< Summary

Information
Class: OzonRepositories.Data.OrderItemRepository
Assembly: OzonRepositories
File(s): /home/runner/work/Studio2Prod/Studio2Prod/OzonRepositories/Data/OrderItemRepository.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 109
Coverable lines: 109
Total lines: 208
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 36
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%2040%
Delete()100%210%
DeleteAsync()0%620%
Get()0%2040%
GetLast()0%2040%
GetAsync()100%210%
GetAsync()100%210%
Update()0%156120%
SwapStudioOrderIdsWithValidationAsync()0%2040%
GetCartItemStatuses()100%210%
GetStatusColors()100%210%
UpdateStatusColor(...)0%2040%
ResetStatusColor(...)0%620%

File(s)

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

#LineLine coverage
 1using Microsoft.EntityFrameworkCore;
 2using OzonDomains;
 3using OzonDomains.Models.OrderCarts;
 4using OzonRepositories.Context;
 5
 6namespace OzonRepositories.Data;
 7
 8 public class OrderItemRepository : MainRepository, IRepository<OrderItem>
 9    {
 10        private readonly OrderRepository _orderRepository;
 11
 012        public OrderItemRepository(ApplicationDbContext context, OrderRepository orderRepository) : base(context)
 13        {
 014            _orderRepository = orderRepository;
 015        }
 16
 17        public async Task<int> Add(OrderItem item)
 18        {
 019            if (item.ItemStatus != null)
 20            {
 021                var existingItemStatus = await _context.ItemStatuses
 022                    .FirstOrDefaultAsync(s => s.Name == item.ItemStatus.Name);
 23
 024                if (existingItemStatus == null)
 25                {
 026                    _context.ItemStatuses.Add(item.ItemStatus);
 27                }
 28                else
 29                {
 030                    item.ItemStatus = existingItemStatus;
 31                }
 32            }
 33
 034            _context.OrderItems.Add(item);
 035            return await _context.SaveChangesAsync();
 036        }
 37
 38        public async Task<int> Delete(OrderItem item)
 39        {
 040            _context.OrderItems.Remove(item);
 041            return await _context.SaveChangesAsync();
 042        }
 43
 44        public async Task<int> DeleteAsync(int id)
 45        {
 046            var item = await _context.OrderItems
 047                .Include(i => i.StudioOrder)
 048                .FirstOrDefaultAsync(i => i.Id == id);
 49
 050            if (item == null)
 051                return 0;
 52
 053            _context.OrderItems.Remove(item);
 054            return await _context.SaveChangesAsync();
 055        }
 56
 57        public async Task<List<OrderItem>> Get()
 58        {
 059            var items = await _context.OrderItems
 060                .Include(i => i.ItemStatus)
 061                .ToListAsync();
 62
 063            foreach (var item in items)
 64            {
 065                if (item.StudioOrderId.HasValue)
 66                {
 067                    item.StudioOrder = await _orderRepository.GetAsync(item.StudioOrderId.Value);
 68                }
 69            }
 70
 071            return items;
 072        }
 73        public async Task<List<OrderItem>> GetLast(int count)
 74        {
 075            var items = await _context.OrderItems
 076                .Include(i => i.ItemStatus)
 077                .OrderByDescending(i => i.Id)
 078                .Take(count)
 079                .ToListAsync();
 80
 081            foreach (var item in items)
 82            {
 083                if (item.StudioOrderId.HasValue)
 84                {
 085                    item.StudioOrder = await _orderRepository.GetAsync(item.StudioOrderId.Value);
 86                }
 87            }
 88
 089            return items;
 090        }
 91
 92        public async Task<OrderItem?> GetAsync(int id)
 93        {
 094            return await _context.OrderItems
 095                .Include(i => i.ItemStatus)
 096                .Include(i => i.StudioOrder)
 097                .FirstOrDefaultAsync(i => i.Id == id);
 098        }
 99
 100        public async Task<OrderItem?> GetAsync(OrderItem value)
 101        {
 0102            return await _context.OrderItems
 0103                .Include(i => i.ItemStatus)
 0104                .Include(i => i.StudioOrder)
 0105                .FirstOrDefaultAsync(i => i.Id == value.Id);
 0106        }
 107
 108        public async Task<int> Update(OrderItem item)
 109        {
 0110            var existingItem = await _context.OrderItems
 0111                .Include(o => o.ItemStatus)
 0112                .FirstOrDefaultAsync(o => o.Id == item.Id);
 113
 0114            if (existingItem == null)
 0115                throw new InvalidOperationException($"OrderItem с Id={item.Id} не найден");
 116
 0117            existingItem.ItemId = item.ItemId;
 0118            existingItem.Quantity = item.Quantity;
 0119            existingItem.Comment = item.Comment;
 0120            existingItem.StudioOrderId = item.StudioOrderId;
 0121            existingItem.OrderItemCode = item.OrderItemCode;
 0122            existingItem.OrderCartId = item.OrderCartId;
 0123            if (item.ItemStatus != null && !string.IsNullOrWhiteSpace(item.ItemStatus.Name))
 124            {
 0125                var normalizedStatusName = item.ItemStatus.Name.Trim().ToLower();
 0126                var existingStatus = await _context.ItemStatuses
 0127                    .FirstOrDefaultAsync(s => s.Name.Trim().ToLower() == normalizedStatusName);
 128
 0129                if (existingStatus == null)
 130                {
 0131                    existingStatus = new ItemStatus { Name = item.ItemStatus.Name.Trim() };
 0132                    _context.ItemStatuses.Add(existingStatus);
 133                }
 134
 0135                existingItem.ItemStatus = existingStatus;
 136            }
 0137            else if (item.ItemStatusId.HasValue && item.ItemStatusId != existingItem.ItemStatusId)
 138            {
 0139                existingItem.ItemStatusId = item.ItemStatusId;
 140            }
 141
 0142            return await _context.SaveChangesAsync();
 0143        }
 144        public async Task<bool> SwapStudioOrderIdsWithValidationAsync(int firstOrderItemId, int secondOrderItemId)
 145        {
 0146            var firstItem = await _context.OrderItems
 0147                .Include(i => i.StudioOrder)
 0148                .FirstOrDefaultAsync(i => i.StudioOrderId == firstOrderItemId);
 149
 0150            var secondItem = await _context.OrderItems
 0151                .Include(i => i.StudioOrder)
 0152                .FirstOrDefaultAsync(i => i.StudioOrderId == secondOrderItemId);
 153
 0154            if (firstItem == null || secondItem == null)
 0155                return false;
 156
 0157            var tempStudioOrderId = firstItem.StudioOrderId;
 0158            firstItem.StudioOrderId = secondItem.StudioOrderId;
 0159            secondItem.StudioOrderId = tempStudioOrderId;
 160
 0161            var result = await _context.SaveChangesAsync();
 0162            return result > 0;
 0163        }
 164        public List<ItemStatus> GetCartItemStatuses()
 165        {
 0166            return _context.ItemStatuses
 0167                .Include(s => s.OrderItems)
 0168                .Include(s => s.StatusColor)
 0169                .ToList();
 170        }
 171
 172        public List<StatusColor> GetStatusColors()
 173        {
 0174            return _context.StatusColors.ToList();
 175        }
 176
 177        public void UpdateStatusColor(int statusId, string colorCode)
 178        {
 0179            var status = _context.ItemStatuses
 0180                .Include(s => s.StatusColor)
 0181                .FirstOrDefault(s => s.Id == statusId);
 182
 0183            if (status == null) return;
 184
 0185            if (status.StatusColor != null)
 186            {
 0187                status.StatusColor.ColorCode = colorCode;
 188            }
 189            else
 190            {
 0191                var newColor = new StatusColor { ColorCode = colorCode };
 0192                _context.StatusColors.Add(newColor);
 0193                status.StatusColor = newColor;
 194            }
 195
 0196            _context.SaveChanges();
 0197        }
 198
 199        public void ResetStatusColor(int statusId)
 200        {
 0201            var status = _context.ItemStatuses.Find(statusId);
 0202            if (status != null)
 203            {
 0204                status.StatusColorId = null;
 0205                _context.SaveChanges();
 206            }
 0207        }
 208}