public async Task <OrphanageDataModel.FinancialData.Bail> GetBailDC(int Bid)
        {
            _logger.Information($"Trying to get Bail with id {Bid}");
            using (var dbContext = new OrphanageDbCNoBinary())
            {
                var bail = await dbContext.Bails.AsNoTracking()
                           .Include(b => b.Account)
                           .Include(b => b.Guarantor)
                           .Include(b => b.Guarantor.Name)
                           .FirstOrDefaultAsync(b => b.Id == Bid);

                if (bail == null)
                {
                    _logger.Warning($"Bail with id{Bid} cannot be found null is returned");
                    return(null);
                }
                bail.OrphansCount = await GetOrphansCount(Bid);

                bail.FamiliesCount = await GetFamiliesCount(Bid);

                _selfLoopBlocking.BlockBailSelfLoop(ref bail);
                _logger.Information($"returned Bail with id {Bid}");
                return(bail);
            }
        }
        public async Task <IEnumerable <OrphanageDataModel.FinancialData.Bail> > GetBails(int Gid)
        {
            _logger.Information($"Trying to get Bails that related to the Guarantor with id {Gid}");
            IList <OrphanageDataModel.FinancialData.Bail> returnedBails = new List <OrphanageDataModel.FinancialData.Bail>();

            using (var dbContext = new OrphanageDbCNoBinary())
            {
                var bails = await(from bail in dbContext.Bails.AsNoTracking()
                                  where bail.GuarantorID == Gid
                                  select bail)
                            .Include(b => b.Account)
                            .ToListAsync();

                if (bails == null || bails.Count == 0)
                {
                    _logger.Information($"guarantor with id({Gid}) has no bails to return, null will be returned");
                    return(null);
                }
                foreach (var bail in bails)
                {
                    var bailToFill = bail;
                    _selfLoopBlocking.BlockBailSelfLoop(ref bailToFill);
                    _logger.Information($"adding bail with id({bail.Id}) to the returned List");
                    returnedBails.Add(bailToFill);
                }
            }
            _logger.Information($"({returnedBails.Count}) records of bails will be returned");
            return(returnedBails);
        }
Exemple #3
0
        public async Task <IEnumerable <OrphanageDataModel.FinancialData.Bail> > GetBails(int Uid)
        {
            IList <OrphanageDataModel.FinancialData.Bail> bailsList = new List <OrphanageDataModel.FinancialData.Bail>();

            using (var _orphanageDBC = new OrphanageDbCNoBinary())
            {
                var bails = await _orphanageDBC.Bails.AsNoTracking()
                            .Include(b => b.Account)
                            .Include(b => b.Guarantor)
                            .Where(b => b.UserId == Uid)
                            .ToListAsync();

                foreach (var bail in bails)
                {
                    OrphanageDataModel.FinancialData.Bail bailsToFill = bail;
                    _selfLoopBlocking.BlockBailSelfLoop(ref bailsToFill);
                    bailsList.Add(bailsToFill);
                }
            }
            return(bailsList);
        }
        public async Task <IEnumerable <OrphanageDataModel.FinancialData.Bail> > GetBails(int Aid)
        {
            IList <OrphanageDataModel.FinancialData.Bail> returnedBails = new List <OrphanageDataModel.FinancialData.Bail>();

            using (var dbContext = new OrphanageDbCNoBinary())
            {
                var bails = await(from bail in dbContext.Bails.AsNoTracking()
                                  where bail.AccountID == Aid
                                  select bail)
                            .Include(b => b.Account)
                            .Include(b => b.Guarantor)
                            .ToListAsync();

                foreach (var bail in bails)
                {
                    var bailToFill = bail;
                    _selfLoopBlocking.BlockBailSelfLoop(ref bailToFill);
                    returnedBails.Add(bailToFill);
                }
            }
            return(returnedBails);
        }