public static async Task <PagedResult <T> > PaginateAsync <T>(this IMongoQueryable <T> collection, string orderBy,
string sortOrder, int page = 1, int resultsPerPage = 10)
{
if (page <= 0)
{
page = 1;
}
if (resultsPerPage <= 0)
{
resultsPerPage = 10;
}
var isEmpty = await collection.AnyAsync() == false;
if (isEmpty)
{
return(PagedResult <T> .Empty);
}
var totalResults = await collection.CountAsync();
var totalPages = (int)Math.Ceiling((decimal)totalResults / resultsPerPage);
List <T> data;
if (string.IsNullOrWhiteSpace(orderBy))
{
data = await collection.Limit(page, resultsPerPage).ToListAsync();
return(PagedResult <T> .Create(data, page, resultsPerPage, totalPages, totalResults));
}
if (sortOrder?.ToLowerInvariant() == "asc")
{
data = await collection.OrderBy(ToLambda <T>(orderBy)).Limit(page, resultsPerPage).ToListAsync();
}
else
{
data = await collection.OrderByDescending(ToLambda <T>(orderBy)).Limit(page, resultsPerPage)
.ToListAsync();
}
return(PagedResult <T> .Create(data, page, resultsPerPage, totalPages, totalResults));
}
public async Task search_todo_should_given_search_filter_should_return_data_based_on_paging_option_requested()
{
SearchTodo query = new SearchTodo {
Title = "Title #1"
};
_todoRepository.GetAllAsync().Returns(todoList.AsQueryable());
var filtered = todoList.Where(x => x.Title.Value.Contains(query.Title));
var expected = PagedResult <Todo> .Create(filtered, 1, 10, 1, 4).Map(x => x.AsDto());
var actuals = await _todosService.SearchAsync(query);
_todoRepository.Received().GetAllAsync();
expected.Items.Count().ShouldBe(actuals.Items.Count());
}
public async Task get_deposits_should_return_paged_results_of_deposits()
{
var query = new GetDeposits();
_consumerService.GetDepositsAsync(query)
.Returns(PagedResult <DepositDetails> .Create(new[] { GetDepositDetails() }, 1, 1, 1, 1));
var result = await _rpc.ndm_getDeposits(query);
await _consumerService.Received().GetDepositsAsync(query);
result.Data.Items.Should().ContainSingle();
result.Data.Page.Should().Be(1);
result.Data.Results.Should().Be(1);
result.Data.TotalPages.Should().Be(1);
result.Data.TotalResults.Should().Be(1);
result.Data.IsEmpty.Should().BeFalse();
VerifyDepositDetails(result.Data.Items.Single());
}
public async Task search_todo_should_given_filter_should_return_data_based_on_paging_option_requested()
{
SearchTodo query = new SearchTodo {
Page = 1, PageSize = 2
};
_todoRepository.GetAllAsync().Returns(todoList.AsQueryable());
var filtered = todoList.Skip(0).Take(2);
var expected = PagedResult <Todo> .Create(filtered, 1, 10, 2, 4).Map(x => x.AsDto());
var actuals = await _todosService.SearchAsync(query);
_todoRepository.Received().GetAllAsync();
expected.Items.Count().ShouldBe(actuals.Items.Count());
}
public async Task should_return_sum_of_consumed_units_for_confirmed_deposit_with_sessions_and_unit_unit_type()
{
var deposit = GetDepositDetails();
var sessions = new List <ConsumerSession>
{
GetConsumerSession(10),
GetConsumerSession(20),
GetConsumerSession(30)
};
var expectedConsumedUnits = (uint)sessions.Sum(s => s.ConsumedUnits);
_sessionRepository.BrowseAsync(Arg.Any <GetConsumerSessions>())
.Returns(PagedResult <ConsumerSession> .Create(sessions, 1, 1, 1, sessions.Count));
var consumedUnits = await _calculator.GetConsumedAsync(deposit);
consumedUnits.Should().Be(expectedConsumedUnits);
await _sessionRepository.Received(1).BrowseAsync(Arg.Any <GetConsumerSessions>());
}
public async Task send_data_request_should_succeed_for_valid_deposit()
{
var depositId = Keccak.Zero;
var deposit = GetDepositDetails(DepositConfirmationTimestamp, DepositExpiryTime);
_depositProvider.GetAsync(depositId).Returns(deposit);
_wallet.IsUnlocked(deposit.Consumer).Returns(true);
var provider = Substitute.For <INdmPeer>();
_providerService.GetPeer(deposit.DataAsset.Provider.Address).Returns(provider);
var sessions = new List <ConsumerSession>
{
GetConsumerSession()
};
var dataRequest = new DataRequest(Keccak.OfAnEmptyString, 1, 1, 1, Array.Empty <byte>(), Address.Zero,
Address.Zero, null);
var sessionsPagedResult = PagedResult <ConsumerSession> .Create(sessions, 1, 1, 1, 1);
_sessionRepository.BrowseAsync(Arg.Any <GetConsumerSessions>()).Returns(sessionsPagedResult);
_dataRequestFactory.Create(deposit.Deposit, deposit.DataAsset.Id, deposit.DataAsset.Provider.Address,
deposit.Consumer, deposit.Pepper).Returns(dataRequest);
var consumedUnits = (uint)sessions.Sum(s => s.ConsumedUnits);
provider.SendDataRequestAsync(dataRequest, consumedUnits).Returns(DataRequestResult.DepositVerified);
var result = await _dataRequestService.SendAsync(depositId);
result.Should().Be(DataRequestResult.DepositVerified);
await _depositProvider.Received(1).GetAsync(depositId);
_wallet.Received(1).IsUnlocked(deposit.Consumer);
await _kycVerifier.DidNotReceive().IsVerifiedAsync(deposit.DataAsset.Id, deposit.Consumer);
_providerService.Received(1).GetPeer(deposit.DataAsset.Provider.Address);
await _sessionRepository.Received(1).BrowseAsync(Arg.Any <GetConsumerSessions>());
_dataRequestFactory.Received(1).Create(deposit.Deposit, deposit.DataAsset.Id,
deposit.DataAsset.Provider.Address, deposit.Consumer, deposit.Pepper);
await provider.Received(1).SendDataRequestAsync(dataRequest, consumedUnits);
await _consumerNotifier.Received(1).SendDataRequestResultAsync(depositId, result);
}
public static PagedResult <T> ToPagedResult <T>(this IEnumerable <T> collection, HttpResponseHeaders headers)
{
var items = collection?.ToArray() ?? Enumerable.Empty <T>().ToArray();
if (items.Any() == false)
{
return(PagedResult <T> .Empty);
}
IEnumerable <string> xTotalCountHeaders;
IEnumerable <string> linkHeaders;
if (headers.TryGetValues("X-Total-Count", out xTotalCountHeaders) == false ||
headers.TryGetValues("Link", out linkHeaders) == false)
{
return(items.PaginateWithoutLimit());
}
var totalResults = xTotalCountHeaders.First();
var totalResultsInt = int.Parse(totalResults);
var link = linkHeaders.First();
var totalPages = int.Parse(GetValueFromLink(link, "last", "page"));
var currentPage = 0;
var nextPage = GetValueFromLink(link, "next", "page");
var prevPage = GetValueFromLink(link, "prev", "page");
if (nextPage != null)
{
currentPage = int.Parse(nextPage) - 1;
}
else if (prevPage != null)
{
currentPage = int.Parse(prevPage) + 1;
}
var resultsPerPage = int.Parse(GetValueFromLink(link, "first", "results"));
return(PagedResult <T> .Create(items, currentPage, resultsPerPage, totalPages, totalResultsInt));
}
public PagedResult <Shelf> Get(int pageNumber, int pageSize, string fields, string orderBy, string orderDirection, string searchQuery)
{
using (IDbConnection db = new SqlConnection(_connectionString))
{
db.Open();
string itemsQry = string.Format(@"Select * from Shelves Order by {0} {1}
Offset (@RowsPerPage * (@PageNumber - 1)) rows Fetch next @RowsPerPage rows only", orderBy, orderDirection);
string countQry = @"SELECT count(*) FROM Shelves";
DynamicParameters dynamicParameters = new DynamicParameters();
dynamicParameters.Add("RowsPerPage", pageSize);
dynamicParameters.Add("PageNumber", pageNumber);
dynamicParameters.Add("TotalCount", ParameterDirection.Output);
var shelves = db.Query <Shelf>(itemsQry, dynamicParameters).ToList();
var totalCount = db.Query <int>(countQry, dynamicParameters).Single();
return(PagedResult <Shelf> .Create(shelves, totalCount, pageNumber, pageSize));
}
}
private void ConfigureMocks(TestConsumer consumer)
{
var depositId = consumer.DepositId;
_consumerRepository.GetAsync(depositId).Returns(consumer.Consumer);
_paymentClaimRepository.BrowseAsync(Arg.Any <GetPaymentClaims>())
.Returns(PagedResult <PaymentClaim> .Empty);
_sessionRepository.BrowseAsync(new GetProviderSessions
{
DepositId = depositId
})
.Returns(PagedResult <ProviderSession> .Create(new List <ProviderSession>(consumer.Sessions), 1, 1, 1, 1));
_receiptsPolicies.CanRequestReceipts(Arg.Any <long>(), Arg.Any <UInt256>()).Returns(true);
_sessionManager.GetConsumerNodes(depositId).Returns(consumer.Nodes.Select(n => n.Node).ToArray());
_receiptProcessor.TryProcessAsync(Arg.Any <ProviderSession>(), _consumer, Arg.Any <INdmProviderPeer>(),
Arg.Any <DataDeliveryReceiptRequest>(), Arg.Any <DataDeliveryReceipt>()).Returns(true);
}
public static async Task<PagedResult<T>> PaginateAsync<T>(this IMongoQueryable<T> collection,
int page = 1, int resultsPerPage = 10)
{
if (page <= 0)
{
page = 1;
}
if (resultsPerPage <= 0)
{
resultsPerPage = 10;
}
var isEmpty = await collection.AnyAsync() == false;
if (isEmpty)
{
return PagedResult<T>.Empty;
}
var totalResults = await collection.CountAsync();
var totalPages = (int)Math.Ceiling((decimal)totalResults / resultsPerPage);
var data = await collection.Limit(page, resultsPerPage).ToListAsync();
return PagedResult<T>.Create(data, page, resultsPerPage, totalPages, totalResults);
}
public static PagedResult <T> Paginate <T>(this IEnumerable <T> collection, int page = 1, int resultsPerPage = 10)
{
if (page <= 0)
{
page = 1;
}
if (resultsPerPage <= 0)
{
resultsPerPage = 10;
}
var isEmpty = !collection.Any();
if (isEmpty)
{
return(PagedResult <T> .Empty);
}
var totalResults = collection.Count();
var totalPages = (int)Math.Ceiling((decimal)totalResults / resultsPerPage);
var data = collection.Limit(page, resultsPerPage).ToList();
return(PagedResult <T> .Create(data, page, resultsPerPage, totalPages, totalResults));
}
public static PagedResult<T> Paginate<T>(this IQueryable<T> source, Paging paging)
{
var isEmpty = source == null || !source.Any();
if (isEmpty)
return PagedResult<T>.Empty;
var totalResults = source.Count();
if (paging == null)
return PagedResult<T>.Create(source.ToList(), 1, totalResults, 1, totalResults);
if (paging.Page <= 0)
paging.Page = 1;
if (paging.PageSize <= 0)
paging.PageSize = 10;
var totalPages = (int)Math.Ceiling((double)totalResults / paging.PageSize);
var data = source.Skip((paging.Page - 1) * paging.PageSize).Take(paging.PageSize).ToList();
return PagedResult<T>.Create(data, paging.Page, paging.PageSize, totalPages, totalResults);
}
public static async Task <PagedResult <T> > PaginateAsync <T>(this IMongoQueryable <T> collection,
int currentPage = 1, int pageSize = 5)
{
if (currentPage <= 0)
{
currentPage = 1;
}
if (pageSize <= 0)
{
pageSize = 5;
}
if (pageSize > 15)
{
pageSize = 15;
}
var isEmpty = await collection.AnyAsync() == false;
if (isEmpty)
{
return(PagedResult <T> .Empty);
}
var totalResults = await collection.CountAsync();
var totalPages = (int)Math.Ceiling((decimal)totalResults / pageSize);
if (currentPage > totalPages)
{
currentPage = totalPages;
}
var paginatedSource = await collection.Limit(currentPage, pageSize).ToListAsync();
return(PagedResult <T> .Create(paginatedSource, currentPage, pageSize, totalPages, totalResults));
}
public static async Task <PagedResult <T> > PaginateAsync <T, TKey>(this IMongoQueryable <T> collection, int resultsPerPage = 10)
where T : IIdentifiable <TKey>
{
if (resultsPerPage <= 0)
{
resultsPerPage = 10;
}
var result = await collection
.Take(resultsPerPage + 1)
.ToListAsync();
var hasNextData = result.Count > resultsPerPage;
if (result.Count > 1 && hasNextData)
{
result.RemoveAt(result.Count - 1);
}
var last = result.LastOrDefault();
return(PagedResult <T> .Create(result, result.Count, last?.Id.ToString(), hasNextData));
}
// If all units are consumed, background processor should not try to refund this deposit.
// Consumed units are not set in databases - they are calculated by DepositUnitsCalculator,
// so we need to remember to always calculate consumed units after reading them from DB
public void Will_not_try_to_refund_consumed_deposit()
{
_processor.Init();
var blockProccesed = Build.A.Block.TestObject;
var consumedDeposit = new Deposit(Keccak.Zero, 10, 1, 1);
var consumedDepositDetails = new DepositDetails(consumedDeposit, null, null, null, 1, null);
consumedDepositDetails.SetConsumedUnits(10);
var refundsResult = PagedResult <DepositDetails> .Create(
new List <DepositDetails> {
consumedDepositDetails
},
1,
1,
1,
1);
_depositRepository.BrowseAsync(Arg.Any <GetDeposits>()).Returns(Task.FromResult(refundsResult));
_blockProcessor.BlockProcessed += Raise.EventWith(new BlockProcessedEventArgs(blockProccesed, Array.Empty <TxReceipt>()));
_consumerNotifier.DidNotReceive().SendClaimedRefundAsync(Arg.Any <Keccak>(), Arg.Any <string>(), Arg.Any <Keccak>());
}
public static async Task <PagedResult <T> > PaginateAsync <T>(this IQueryable <T> collection,
int page = 1, int resultsPerPage = 10)
{
if (page <= 0)
{
page = 1;
}
if (resultsPerPage <= 0)
{
resultsPerPage = 10;
}
var isEmpty = collection.Any() == false;
if (isEmpty)
{
return(PagedResult <T> .Empty);
}
var totalResults = collection.Count();
var totalPages = (int)Math.Ceiling((decimal)totalResults / resultsPerPage);
var data = collection.Take(resultsPerPage).Skip(page * resultsPerPage).ToList();
return(PagedResult <T> .Create(data, page, resultsPerPage, totalPages, totalResults));
}
public MaterialActor(MaterialRepository materialRepository, IMapper mapper)
{
_materialRepository = materialRepository;
_mapper = mapper;
ReceiveAsync <CreateMaterialBindingModel>(async command =>
{
Sender.Tell(await _materialRepository.AddAsync(_mapper.Map <Domain.Material>(command)));
});
ReceiveAsync <UpdateMaterialBindingModel>(async command =>
{
await _materialRepository.UpdateAsync(_mapper.Map <Domain.Material>(command));
Sender.Tell("Done!");
});
ReceiveAsync <DeleteMaterialCommand>(async command =>
{
await _materialRepository.DeleteAsync(command.Id);
Sender.Tell("Done!");
});
ReceiveAsync <GetMaterialByIdCommand>(async command =>
{
Sender.Tell(_mapper.Map <GetMaterialResponseModel>(await _materialRepository.GetAsync(command.Id)));
});
ReceiveAsync <SearchMaterialByNameQueryModel>(async command =>
{
var result = await _materialRepository.SearchByNameAsync(command);
Sender.Tell(PagedResult <GetMaterialResponseModel>
.Create(result.data.Select(x => _mapper.Map <GetMaterialResponseModel>(x)).ToList(),
command.Page, command.Results,
Convert.ToInt32(Math.Ceiling((double)result.statistics.TotalResults / command.Results)),
result.statistics.TotalResults));
});
}
protected static void Initialize()
{
UserId = "userId";
Username = "******";
Email = "*****@*****.**";
ExternalId = "externalId";
Provider = Providers.Collectively;
Password = "******";
Hash = "hash";
Role = Roles.User;
UserRepositoryMock = new Mock <IUserRepository>();
EncrypterMock = new Mock <IEncrypter>();
SecuredOperationServiceMock = new Mock <IOneTimeSecuredOperationService>();
UserService = new UserService(UserRepositoryMock.Object,
EncrypterMock.Object, SecuredOperationServiceMock.Object);
User = new User(UserId, Email, Role, Provider);
Query = new BrowseUsers();
Users = PagedResult <User> .Create(new [] { User }, 1, 1, 1, 1);
EncrypterMock.Setup(x => x.GetSalt(Moq.It.IsAny <string>())).Returns("salt");
EncrypterMock
.Setup(x => x.GetHash(Moq.It.IsAny <string>(), Moq.It.IsAny <string>()))
.Returns(Hash);
}
public static async Task <PagedResult <Remark> > QueryAsync(this IMongoCollection <Remark> remarks,
BrowseRemarks query)
{
if (query.Page <= 0)
{
query.Page = 1;
}
if (query.Results <= 0)
{
query.Results = 10;
}
var filter = FilterDefinition <Remark> .Empty;
var totalCount = await remarks.CountAsync(filter);
var totalPages = (int)totalCount / query.Results + 1;
var result = await remarks.Find(filter)
.Skip(query.Results * (query.Page - 1))
.Limit(query.Results)
.ToListAsync();
return(PagedResult <Remark> .Create(result, query.Page, query.Results, totalPages, totalCount));
}
public void AbsenceDaysCannotBookTests(AbsenceRange absenceRange, WorkingPattern workingPattern, IEnumerable <PublicHoliday> publicHolidays, IEnumerable <AbsenceDay> alreadyBookedAbsenceDays, IEnumerable <INotAbsenceDay> expectedAbsenceDays)
{
// Arrange
_mockHRDataService.Setup(m => m.RetrievePublicHolidays(It.IsAny <Int32>(), It.IsAny <Int32>(), It.IsAny <Expression <Func <PublicHoliday, bool> > >(), It.IsAny <List <OrderBy> >(), It.IsAny <Paging>())).Returns(PagedResult <PublicHoliday> .Create(publicHolidays, 1, publicHolidays.Count(), 1, publicHolidays.Count()));
_mockHRDataService.Setup(m => m.RetrieveAbsenceRangeBookedAbsenceDays(It.IsAny <AbsenceRange>()))
.Returns(alreadyBookedAbsenceDays);
// Act
var actualAbsenceDays = _hrBusinessService.RetrieveCannotBeBookedDays(absenceRange, workingPattern);
// Assert
actualAbsenceDays.ShouldBeEquivalentTo(expectedAbsenceDays);
_mockHRDataService.Verify(m => m.RetrievePublicHolidays(It.IsAny <Int32>(), It.IsAny <Int32>(), It.IsAny <Expression <Func <PublicHoliday, bool> > >(), It.IsAny <List <OrderBy> >(), It.IsAny <Paging>()), Times.Once);
_mockHRDataService.Verify(m => m.RetrieveAbsenceRangeBookedAbsenceDays(It.IsAny <AbsenceRange>()), Times.Once);
}
public static async Task <PagedResult <Remark> > QueryAsync(this IMongoCollection <Remark> remarks,
BrowseRemarks query)
{
if (!query.IsLocationProvided() && query.AuthorId.Empty() && query.ResolverId.Empty())
{
query.Latest = true;
}
if (query.Page <= 0)
{
query.Page = 1;
}
if (query.Results <= 0)
{
query.Results = 10;
}
if (query.Results > 1000)
{
query.Results = 1000;
}
var filterBuilder = new FilterDefinitionBuilder <Remark>();
var filter = FilterDefinition <Remark> .Empty;
if (query.IsLocationProvided() && !query.SkipLocation)
{
var maxDistance = query.Radius > 0 ? (double?)query.Radius / 1000 / 6378.1 : null;
filter = filterBuilder.NearSphere(x => x.Location,
query.Longitude, query.Latitude, maxDistance);
}
if (query.AuthorId.NotEmpty())
{
filter = filter & filterBuilder.Where(x => x.Author.UserId == query.AuthorId);
if (query.OnlyLiked)
{
filter = filter & filterBuilder.Where(x => x.Votes.Any(v => v.UserId == query.AuthorId && v.Positive));
}
else if (query.OnlyDisliked)
{
filter = filter & filterBuilder.Where(x => x.Votes.Any(v => v.UserId == query.AuthorId && !v.Positive));
}
}
if (query.ResolverId.NotEmpty())
{
filter = filter & filterBuilder.Where(x => x.State.State == "resolved" &&
x.State.User.UserId == query.ResolverId);
}
if (!query.Description.Empty())
{
filter = filter & filterBuilder.Where(x => x.Description.Contains(query.Description));
}
if (query.Categories?.Any() == true)
{
filter = filter & filterBuilder.Where(x => query.Categories.Contains(x.Category.Name));
}
if (query.Tags?.Any() == true)
{
filter = filter & filterBuilder.Where(x => x.Tags.Any(y => query.Tags.Contains(y)));
}
if (query.States?.Any() == true)
{
filter = filter & filterBuilder.Where(x => query.States.Contains(x.State.State));
}
if (!query.Disliked)
{
filter = filter & filterBuilder.Where(x => x.Rating > NegativeVotesThreshold);
}
if (query.GroupId.HasValue && query.GroupId != Guid.Empty)
{
filter = filter & filterBuilder.Where(x => x.Group.Id == query.GroupId);
}
if (query.UserFavorites.NotEmpty())
{
filter = filterBuilder.Where(x => x.UserFavorites.Contains(query.UserFavorites));
}
var totalCount = await remarks.CountAsync(_ => true);
var filteredRemarks = remarks.Find(filter);
var totalPages = (int)totalCount / query.Results + 1;
var findResult = filteredRemarks
.Skip(query.Results * (query.Page - 1))
.Limit(query.Results);
findResult = SortRemarks(query, findResult);
var result = await findResult.ToListAsync();
return(PagedResult <Remark> .Create(result, query.Page, query.Results, totalPages, totalCount));
}
public async Task <DepositsReport> GetAsync(GetDepositsReport query)
{
var deposits = query.DepositId is null
? await _depositRepository.BrowseAsync(new GetDeposits
{
Results = int.MaxValue
})
: PagedResult <DepositDetails> .Create(new[] { await _depositRepository.GetAsync(query.DepositId) },
1, 1, 1, 1);
if (!deposits.Items.Any() || deposits.Items.Any(d => d is null))
{
return(DepositsReport.Empty);
}
var foundDeposits = deposits.Items
.Where(d => (query.Provider is null || d.DataAsset.Provider.Address == query.Provider) &&
(query.AssetId is null || d.DataAsset.Id == query.AssetId))
.ToDictionary(d => d.Id, d => d);
if (!foundDeposits.Any())
{
return(DepositsReport.Empty);
}
var assetIds = foundDeposits.Select(d => d.Value.DataAsset.Id);
var receipts = await _receiptRepository.BrowseAsync(query.DepositId, query.AssetId);
var depositsReceipts = receipts.Where(r => assetIds.Contains(r.DataAssetId))
.GroupBy(r => r.DepositId).ToDictionary(r => r.Key, r => r.AsEnumerable());
var page = query.Page;
if (page <= 0)
{
page = 1;
}
var results = query.Results;
if (results <= 0)
{
results = 10;
}
var timestamp = (uint)_timestamper.EpochSeconds;
var skip = (page - 1) * results;
var items = new List <DepositReportItem>();
foreach (var(_, deposit) in foundDeposits.OrderByDescending(d => d.Value.Timestamp).Skip(skip)
.Take(results))
{
depositsReceipts.TryGetValue(deposit.Id, out var depositReceipts);
var expired = deposit.IsExpired(timestamp);
var receiptItems = depositReceipts?.Select(r => new DataDeliveryReceiptReportItem(r.Id, r.Number,
r.SessionId, r.ConsumerNodeId, r.Request, r.Receipt, r.Timestamp, r.IsMerged, r.IsClaimed));
var sessions = await _sessionRepository.BrowseAsync(new GetConsumerSessions
{
DepositId = deposit.Id,
Results = int.MaxValue
});
var consumedUnits = sessions.Items.Any() ? (uint)sessions.Items.Sum(s => s.ConsumedUnits) : 0;
items.Add(new DepositReportItem(deposit.Id, deposit.DataAsset.Id, deposit.DataAsset.Name,
deposit.DataAsset.Provider.Address, deposit.DataAsset.Provider.Name, deposit.Deposit.Value,
deposit.Deposit.Units, deposit.Consumer, deposit.Timestamp, deposit.Deposit.ExpiryTime, expired,
deposit.Transaction?.Hash, deposit.ConfirmationTimestamp, deposit.Confirmations,
deposit.RequiredConfirmations, deposit.Confirmed, deposit.Rejected,
deposit.ClaimedRefundTransaction?.Hash, deposit.RefundClaimed, consumedUnits, receiptItems));
}
var(total, claimed, refunded) = CalculateValues(foundDeposits, depositsReceipts);
var totalResults = foundDeposits.Count;
var totalPages = (int)Math.Ceiling((double)totalResults / query.Results);
return(new DepositsReport(total, claimed, refunded,
PagedResult <DepositReportItem> .Create(items.OrderByDescending(i => i.Timestamp).ToList(),
query.Page, query.Results, totalPages, totalResults)));
}
public PagedResult <Product> Get(int pageNumber, int pageSize, string fields, string orderBy, string orderDirection, string searchQuery)
{
using (IDbConnection db = new SqlConnection(_connectionString))
{
db.Open();
//string itemsQry = string.Format(@"Select Products.Id,
// Products.Name,
// Products.ShelfId,
// Shelves.Id,
// Shelves.Name,
// Shelves.ShelfCode
// from Products as Products
// join Shelves as Shelves on Products.ShelfId = Shelves.Id
// Order by Products.{0} {1}
// Offset (@RowsPerPage * (@PageNumber - 1)) rows Fetch next @RowsPerPage rows only", orderBy, orderDirection);
string itemsQry = string.Format(@"Select p.*,
s.Id as Id,
s.Name,
s.ShelfCode,
pa.Id as Id,
pa.ActivityType,
pa.ProductId,
pa.Total,
pa.AuditById,
pa.Date
from Products as p
left join Shelves as s on p.ShelfId = s.Id
left join ProductActivities as pa on p.Id = pa.ProductId
Order by p.{0} {1}
Offset (@RowsPerPage * (@PageNumber - 1)) rows Fetch next @RowsPerPage rows only", orderBy, orderDirection);
string countQry = @"SELECT count(*) FROM Products";
DynamicParameters dynamicParameters = new DynamicParameters();
dynamicParameters.Add("RowsPerPage", pageSize);
dynamicParameters.Add("PageNumber", pageNumber);
dynamicParameters.Add("TotalCount", ParameterDirection.Output);
var products = db.Query <Product, Shelf, ProductActivity, Product>(itemsQry,
(p, s, pa) => {
p.Shelf = s;
if (p.ProductActivities == null)
{
p.ProductActivities = new List <ProductActivity>();
}
if (pa != null)
{
p.ProductActivities.Add(pa);
}
return(p);
},
dynamicParameters)
.ToList();
var totalCount = db.Query <int>(countQry, dynamicParameters).Single();
return(PagedResult <Product> .Create(products, totalCount, pageNumber, pageSize));
}
}
public static PagedResult <T> ToPagedResult <T>(this IQueryable <T> list, IRequestParameters <T> request) where T : Entity
{
return(PagedResult <T> .Create(list, request));
}
private static async Task <IPagedResult <T> > GetPageAsync <T>(IQueryable <T> results, int pageSize, int pageOffset) where T : IEntity
{
return(PagedResult <T> .Create(results.Skip(pageOffset).Take(pageSize), await results.CountAsync()));
}
public static PagedResult <TDestination> MapToPagedResult <TDestination>(this IMapper mapper, PagedResultBase source)
{
var listDest = mapper.MapToList <TDestination>(source.GetEnumerableItems());
return(PagedResult <TDestination> .Create(listDest, source.CurrentPage, source.ResultsPerPage, source.TotalPages, source.TotalResults));
}
public async Task <DepositsReport> GetAsync(GetDepositsReport query)
{
PagedResult <DepositDetails> deposits;
if (query.DepositId == null)
{
deposits =
await _depositRepository.BrowseAsync(new GetDeposits
{
Results = int.MaxValue
});
}
else
{
DepositDetails?detailsOfOne = await _depositRepository.GetAsync(query.DepositId);
if (detailsOfOne is null)
{
return(DepositsReport.Empty);
}
deposits = PagedResult <DepositDetails> .Create(new[] { detailsOfOne },
1, 1, 1, 1);
}
if (deposits.Items.Count == 0)
{
return(DepositsReport.Empty);
}
if (!deposits.Items.Any() || deposits.Items.Any(d => d is null))
{
return(DepositsReport.Empty);
}
Dictionary <Keccak, DepositDetails> foundDeposits = deposits.Items
.Where(d => (query.Provider is null || d.DataAsset.Provider.Address == query.Provider) &&
(query.AssetId is null || d.DataAsset.Id == query.AssetId))
.ToDictionary(d => d.Id, d => d);
if (!foundDeposits.Any())
{
return(DepositsReport.Empty);
}
IEnumerable <Keccak> assetIds = foundDeposits.Select(d => d.Value.DataAsset.Id);
IReadOnlyList <DataDeliveryReceiptDetails> receipts = await _receiptRepository.BrowseAsync(query.DepositId, query.AssetId);
Dictionary <Keccak, IEnumerable <DataDeliveryReceiptDetails> > depositsReceipts = receipts.Where(r => assetIds.Contains(r.DataAssetId))
.GroupBy(r => r.DepositId).ToDictionary(r => r.Key, r => r.AsEnumerable());
int page = query.Page;
if (page <= 0)
{
page = 1;
}
int results = query.Results;
if (results <= 0)
{
results = 10;
}
uint timestamp = (uint)_timestamper.EpochSeconds;
int skip = (page - 1) * results;
List <DepositReportItem> items = new List <DepositReportItem>();
foreach ((Keccak _, DepositDetails deposit) in foundDeposits.OrderByDescending(d => d.Value.Timestamp).Skip(skip)
.Take(results))
{
depositsReceipts.TryGetValue(deposit.Id, out IEnumerable <DataDeliveryReceiptDetails>?depositReceipts);
bool expired = deposit.IsExpired(timestamp);
IEnumerable <DataDeliveryReceiptReportItem>?receiptItems = depositReceipts?.Select(r => new DataDeliveryReceiptReportItem(r.Id, r.Number,
r.SessionId, r.ConsumerNodeId, r.Request, r.Receipt, r.Timestamp, r.IsMerged, r.IsClaimed));
PagedResult <ConsumerSession> sessions = await _sessionRepository.BrowseAsync(new GetConsumerSessions
{
DepositId = deposit.Id,
Results = int.MaxValue
});
uint consumedUnits = sessions.Items.Any() ? (uint)sessions.Items.Sum(s => s.ConsumedUnits) : 0;
items.Add(ToReportItem(deposit, expired, consumedUnits, receiptItems ?? Enumerable.Empty <DataDeliveryReceiptReportItem>()));
}
(UInt256 total, UInt256 claimed, UInt256 refunded) = CalculateValues(foundDeposits, depositsReceipts);
int totalResults = foundDeposits.Count;
int totalPages = (int)Math.Ceiling((double)totalResults / query.Results);
return(new DepositsReport(total, claimed, refunded,
PagedResult <DepositReportItem> .Create(items.OrderByDescending(i => i.Timestamp).ToList(),
query.Page, query.Results, totalPages, totalResults)));
}
