< Summary

Class:WinSolutions.Sveta.Server.Services.Implements.BankAccountService
Assembly:WinSolutions.Sveta.Server
File(s):/opt/dev/sveta_api_build/WinSolutions.Sveta.Server/Services/Implements/BankAccountService.cs
Covered lines:97
Uncovered lines:8
Coverable lines:105
Total lines:161
Line coverage:92.3% (97 of 105)
Covered branches:36
Total branches:62
Branch coverage:58% (36 of 62)

Metrics

MethodLine coverage Branch coverage
.ctor(...)100%100%
ContragentExists()100%100%
GetBankAccounts()100%100%
GetBankAccountsForContragent()90%66.66%
GetBankAccount()100%100%
FindBankAccount()100%100%
CreateBankAccount()80%50%
UpdateBankAccount()81.81%50%
DeleteBankAccount()75%50%
Sort(...)100%54.34%

File(s)

/opt/dev/sveta_api_build/WinSolutions.Sveta.Server/Services/Implements/BankAccountService.cs

#LineLine coverage
 1using System.Collections.Generic;
 2using System.Linq;
 3using System.Threading.Tasks;
 4using Microsoft.EntityFrameworkCore;
 5using Microsoft.Extensions.Logging;
 6using WinSolutions.Sveta.Server.Data.DataModel.Contexts;
 7using WinSolutions.Sveta.Server.Data.DataModel.Entities;
 8using WinSolutions.Sveta.Server.Services.Interfaces;
 9using WinSolutions.Sveta.Common;
 10using WinSolutions.Sveta.Common.Extensions;
 11
 12namespace WinSolutions.Sveta.Server.Services.Implements
 13{
 14    public class BankAccountService : SvetaServiceBase, IBankAccountService
 15    {
 16        private readonly SvetaDbContext _db;
 17        private readonly ILogger<BankAccountService> _logger;
 18        public BankAccountService(SvetaDbContext db, ILogger<BankAccountService> logger, IAuthenticationService authenti
 419            : base(authenticationService)
 420        {
 421            _db = db;
 422            _logger = logger;
 423        }
 24
 625        public async Task<bool> ContragentExists(long contragentId) => await _db.Contragents
 626            .AsNoTracking()
 627            .Where(e => e.Id == contragentId)
 628            .Where(e => !e.IsDeleted)
 629            .AnyAsync();
 30
 31        public async Task<List<BankAccount>> GetBankAccounts(int page, int? limit, string filter, long? contragentId = n
 1032        {
 1033            var items = _db.BankAccounts
 1034               .Include(x => x.Contragent)
 1035               .Include(d => d.RecState)
 1036               .AsNoTracking()
 1037               .Where(d => !d.IsDeleted)
 1038               .Where(c=> contragentId == null || c.Contragent.Id == contragentId)
 1039               .Where(x => string.IsNullOrWhiteSpace(filter) || x.BankName.ToUpper().Contains(filter.ToUpper())
 1040                                                                 || x.Contragent.FullName.ToUpper().Contains(filter.ToUp
 1041                                                                 || x.Contragent.ShortName.ToUpper().Contains(filter.ToU
 42
 1043            items = Sort(items, sort?.ToLower());
 1044            if(limit != null)
 1045            {
 1046                items = items.Skip(page * (int)limit)
 1047               .Take((int)limit);
 1048            }
 1049            return
 1050               await items
 1051               .ToListAsync();
 1052        }
 53
 54        public async Task<List<BankAccount>> GetBankAccountsForContragent(long contragentId, int page, int limit, string
 655        {
 656            if (!(await ContragentExists(contragentId)))
 057            {
 058                throw new KeyNotFoundException($"Contragent record #{contragentId} not found");
 59            }
 60
 661            var items = _db.BankAccounts
 662               .Include(x => x.Contragent)
 663               .Include(d => d.RecState)
 664               .AsNoTracking()
 665               .Where(d => !d.IsDeleted)
 666               .Where(c => c.Contragent.Id == contragentId)
 667               .Where(x => string.IsNullOrWhiteSpace(filter) || (x.BankName.ToUpper().Contains(filter.ToUpper())
 668                                                                 || x.Contragent.FullName.ToUpper().Contains(filter.ToUp
 669                                                                 || x.Contragent.ShortName.ToUpper().Contains(filter.ToU
 70
 671            items = Sort(items, sort?.ToLower());
 72
 673            return
 674               await items
 675               .Skip(page * limit)
 676               .Take(limit)
 677               .ToListAsync();
 678        }
 79
 880        public async Task<BankAccount> GetBankAccount(long id, long? contragentId = null) => await _db.BankAccounts
 881            .Include(x => x.Contragent)
 882            .Include(d => d.RecState)
 883            .Where(e => !e.IsDeleted)
 884            .Where(c => contragentId == null || c.Contragent.Id == contragentId)
 885            .FirstOrDefaultAsync(n => n.Id == id);
 86
 87        public async Task<BankAccount> FindBankAccount(long id, long contragentId)
 488        {
 489            return await _db.BankAccounts
 490                .Include(x => x.Contragent)
 491                .Include(d => d.RecState)
 492                .Where(x => !x.IsDeleted && !x.Contragent.IsDeleted)
 493                .FirstOrDefaultAsync(x => x.Id == id && x.Contragent.Id == contragentId);
 494        }
 95
 96        public async Task<BankAccount> CreateBankAccount(BankAccount data)
 1297        {
 1298            if(_db.BankAccounts.Any(x => !x.IsDeleted
 1299                                         && x.Bik.ToLower() == data.Bik.NormalizeName().ToLower()
 12100                                         && x.SettlementAccount.ToLower() == data.SettlementAccount.NormalizeName().ToLo
 0101            {
 0102                throw new System.Exception("Такой счет уже существует");
 103            }
 104
 12105            _db.BankAccounts.Add(data);
 12106            await _db.SaveChangesAsync(CurrentUserId);
 12107            return data;
 12108        }
 109
 110        public async Task<BankAccount> UpdateBankAccount(BankAccount data)
 1111        {
 1112            if (_db.BankAccounts.Any(x => !x.IsDeleted
 1113                                          && x.Bik.ToLower() == data.Bik.NormalizeName().ToLower()
 1114                                          && x.SettlementAccount.ToLower() == data.SettlementAccount.NormalizeName().ToL
 1115                                          && x.Id != data.Id))
 0116            {
 0117                throw new System.Exception("Такой счет уже существует");
 118            }
 119
 1120            _db.BankAccounts.Update(data);
 1121            await _db.SaveChangesAsync(CurrentUserId);
 1122            return data;
 1123        }
 124
 125        public async Task DeleteBankAccount(long id)
 1126        {
 1127            var account = _db.BankAccounts.Find(id);
 1128            if (account == null)
 0129            {
 0130                throw new KeyNotFoundException($"Bank account record #{id} not found");
 131            }
 1132            account.IsDeleted = true;
 1133            await _db.SaveChangesAsync(CurrentUserId);
 1134        }
 135
 136        /// <summary>
 137        /// Сортирует BankAccount по полям
 138        /// </summary>
 139        /// <param name="items"></param>
 140        /// <param name="sort">сортировка по умолчанию
 141        /// по id - id|desc,
 142        /// bankName,bankName|desc
 143        /// bik,bik|desc
 144        /// settlementAccount,settlementAccount|desc
 145        /// correspondentAccount,correspondentAccount|desc</param>
 146        /// <returns></returns>
 16147        private IQueryable<BankAccount> Sort(IQueryable<BankAccount> items, string sort = default) => (sort ?? "").ToLow
 16148        {
 16149            "bankname" => items.OrderBy(d => d.BankName),
 16150            "bankname|desc" => items.OrderByDescending(d => d.BankName),
 16151            "bik" => items.OrderBy(d => d.Bik),
 16152            "bik|desc" => items.OrderByDescending(d => d.Bik),
 16153            "settlementaccount" => items.OrderBy(d => d.SettlementAccount),
 16154            "settlementaccount|desc" => items.OrderByDescending(d => d.SettlementAccount),
 16155            "correspondentaccount" => items.OrderBy(d => d.CorrespondentAccount),
 16156            "correspondentaccount|desc" => items.OrderByDescending(d => d.CorrespondentAccount),
 16157            "id|desc" => items.OrderByDescending(d => d.Id),
 16158            _ => items.OrderBy(d => d.Id),
 16159        };
 160    }
 161}
Generated by: ReportGenerator 4.6.1.0
08/27/2020 - 08:55:01
GitHub | www.palmmedia.de

Methods/Properties

.ctor(...)
ContragentExists()
GetBankAccounts()
GetBankAccountsForContragent()
GetBankAccount()
FindBankAccount()
CreateBankAccount()
UpdateBankAccount()
DeleteBankAccount()
Sort(...)