protected void SetPaginator(IPaginator paginator)
{
_paginator = paginator;
_paginator.RefreshCommand.CanExecuteChanged += RefreshCommandCanExecuteChanged;
_paginator.PropertyChanged += PaginatorPropertyChanged;
UpdatePageSize();
}
public CommentsController(IPostCommentService postCommentService, IPostService postService, IMappingService mappingService, IPaginator paginator)
: base(mappingService)
{
this.postCommentService = postCommentService ?? throw new ArgumentNullException();
this.postService = postService ?? throw new ArgumentNullException();
this.paginator = paginator ?? throw new ArgumentNullException();
}
public PaginatorControl()
{
InitializeComponent();
_pagingControlViewModel = new PaginatorControlViewModel();
Paginator = _pagingControlViewModel;
DataContext = _pagingControlViewModel;
CommandModel nextPageCommand = _pagingControlViewModel.NextPCommand;
ButtonNextPage.Command = nextPageCommand.Command;
ButtonNextPage.CommandBindings.Add(new CommandBinding(nextPageCommand.Command, nextPageCommand.OnExecute, nextPageCommand.OnCanExecute));
CommandModel previusPageCommand = _pagingControlViewModel.PreviusPCommand;
ButtonPreviusPage.Command = previusPageCommand.Command;
ButtonPreviusPage.CommandBindings.Add(new CommandBinding(previusPageCommand.Command, previusPageCommand.OnExecute, previusPageCommand.OnCanExecute));
CommandModel lastPageCommand = _pagingControlViewModel.LastPCommand;
ButtonLastPage.Command = lastPageCommand.Command;
ButtonLastPage.CommandBindings.Add(new CommandBinding(lastPageCommand.Command, lastPageCommand.OnExecute, lastPageCommand.OnCanExecute));
CommandModel firstPageCommand = _pagingControlViewModel.FirstPCommand;
ButtonFirstPage.Command = firstPageCommand.Command;
ButtonFirstPage.CommandBindings.Add(new CommandBinding(firstPageCommand.Command, firstPageCommand.OnExecute, firstPageCommand.OnCanExecute));
}
protected void SetPaginator(IPaginator paginator)
{
_paginator = paginator;
_paginator.RefreshCommand.CanExecuteChanged += RefreshCommandCanExecuteChanged;
_paginator.PropertyChanged += PaginatorPropertyChanged;
UpdatePageSize();
}
public OrderDetailService(IRepository repository, IReadOnlyRepository readOnlyRepository, IMapper mapper, IPaginator paginator)
{
_repository = repository;
_readOnlyRepository = readOnlyRepository;
_mapper = mapper;
_paginator = paginator;
}
public CartService(IReadOnlyRepository readOnlyRepository, IMapper mapper, IPaginator paginator, IRepository repository)
{
_readOnlyRepository = readOnlyRepository;
_mapper = mapper;
_paginator = paginator;
_repository = repository;
}
public static Task <PaginatedResult <TItem> > MakePageAsync <TCount, TItem>(this IPaginator paginator, IRepositoryBase repository,
IQueryable <TCount> countQuery,
IQueryable <TItem> itemsQuery,
PaginatedQuery model, CancellationToken cancellationToken = default)
where TCount : class where TItem : class
{
if (paginator == null)
{
throw new ArgumentNullException(nameof(paginator));
}
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
if (countQuery == null)
{
throw new ArgumentNullException(nameof(countQuery));
}
if (itemsQuery == null)
{
throw new ArgumentNullException(nameof(itemsQuery));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
return(paginator.MakePageAsync(repository, countQuery, itemsQuery, model.Page, model.PageSize, cancellationToken));
}
public ExampleService(IRepository repository, IReadOnlyRepository readOnlyRepository, IMapper mapper, IPaginator paginator)
{
_repository = repository;
_readOnlyRepository = readOnlyRepository;
_mapper = mapper;
_paginator = paginator;
}
public ProductDetailsService(IReadOnlyRepository readOnlyRepository, IMapper mapper, IPaginator paginator, IRepository repository)
{
_readOnlyRepository = readOnlyRepository;
_mapper = mapper;
_paginator = paginator;
_repository = repository;
}
public BaseRequest()
{
License = string.Empty;
RequestorId = 0;
AppId = 0;
Paginator = new Paginator();
}
public AlarmsPage()
{
_paginator = new Paginator <Alarm, AlarmSampleId>(
alarm => new AlarmSampleId(alarm), (item, newItem) => item.UpdateFrom(newItem));
SetPaginator(_paginator);
AutoRefresh = true;
}
public ProductService(IRepository repository, IReadOnlyRepository readOnlyRepository, IMapper mapper, IPaginator paginator)
{
_repository = repository;
_readOnlyRepository = readOnlyRepository;
_mapper = mapper;
_paginator = paginator;
product = new Product();
}
public ProductsService(IReadOnlyRepository readOnlyRepository, IMapper mapper, IPaginator paginator, IRepository repository, IImageResizer resizer)
{
_readOnlyRepository = readOnlyRepository;
_mapper = mapper;
_paginator = paginator;
_repository = repository;
_resizer = resizer;
}
public UsersPage()
{
_paginator = new Paginator <User, string>(
user => user.Name, (user, newUser) => user.UpdateFrom(newUser));
SetPaginator(_paginator);
_setPasswordCommand = new DelegateCommand(SetPasswordCommandExecuted, SetPasswordCommandCanExecute);
_editUserCommand = new DelegateCommand(EditUserCommandExecuted, EditUserCommandCanExecute);
_addUserCommand = new DelegateCommand(AddUserCommandExecuted);
}
public static IQueryable <T> Paginate <T>(this IQueryable <T> source, IPaginator paginator)
{
if (paginator is null)
{
throw new ArgumentNullException(nameof(paginator));
}
return(source.Skip((paginator.PageIndex - 1) * paginator.PageSize).Take(paginator.PageSize));
}
public PatronService(
IRentalPortalDbContext context,
IMapper mapper,
IPaginator <Patron> paginator)
{
_context = context;
_mapper = mapper;
_paginator = paginator;
}
protected override void EstablishContext()
{
base.EstablishContext();
Paginator = new Paginator<Item, int>(
item => item.Criteria,
(item, newItem) => item.Value = newItem.Value)
{
PageSize = 3
};
}
public MainViewModel(IPaginator paginator, IPrinting printing, IDialogService dialogService, IDispatcher dispatcher)
{
this.paginator = paginator;
this.printing = printing;
this.dialogService = dialogService;
this.dispatcher = dispatcher;
SupportedPrinters = new ObservableCollection <PrinterModel>();
SupportedPageSizes = new ObservableCollection <PageSizeModel>();
SupportedPageOrientations = new ObservableCollection <PageOrientationModel>();
}
private static IEnumerable <Task <ICollectionPage <T> > > FindAllPagesAsyncImpl <T>(
IPaginator <T> instance,
int pageCount,
CancellationToken cancellationToken)
{
Debug.Assert(instance != null, "instance != null");
for (var pageIndex = 0; pageIndex < pageCount; pageIndex++)
{
yield return(RetryOnFault(() => instance.FindPageAsync(pageIndex, cancellationToken), MaxRetryCount));
}
}
public ListMessagesQuery
(
IReadOnlyMessageBoard state,
IPaginator <MessageModel> messagePaginator
)
{
_state = state
?? throw new ArgumentNullException(nameof(state));
_messagePaginator = messagePaginator
?? throw new ArgumentNullException(nameof(messagePaginator));
}
/// <summary>Finds a collection of all pages.</summary>
/// <param name="instance">The instance of <see cref="IPaginator{T}"/> that provides the pages.</param>
/// <param name="pageSize">The maximum number of page elements.</param>
/// <param name="pageCount">The number of pages to get.</param>
/// <typeparam name="T">The type of elements on the page.</typeparam>
/// <exception cref="ArgumentNullException">The value of <paramref name="instance"/> is a null reference.</exception>
/// <returns>A collection of pages.</returns>
public static IEnumerable <Lazy <ICollectionPage <T> > > FindAllPages <T>(this IPaginator <T> instance, int pageSize, int pageCount)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
for (var pageIndex = 0; pageIndex < pageCount; pageIndex++)
{
var page = pageIndex;
yield return(new Lazy <ICollectionPage <T> >(() => instance.FindPage(page, pageSize)));
}
}
} ///Выборка из бд
public BaseDataProvider(IQueryable <T> query, IPaginator paginator)
{
this.query = query;
this.CurrentPage = paginator.Page;
this.PageSize = paginator.PerPage;
this.SkipCountRecord = ((((this.CurrentPage <= 0) ? 1 : this.CurrentPage) - 1) * this.PageSize);
this.TotalCountRecord = this.query.Count();
this.Collection = this.query.Skip(this.SkipCountRecord).Take(this.PageSize).ToList();///skip - пропускает определенное кол-во елементов,take - извлекает определенное кол-во ел.
this.CurrentCountRecord = this.Collection.Count();
this.PageCount = Convert.ToInt32(Math.Ceiling((double)this.TotalCountRecord / (this.PageSize <= 0 ? 1 : this.PageSize)));
}
public SpotifyClientConfig WithDefaultPaginator(IPaginator defaultPaginator)
{
Ensure.ArgumentNotNull(defaultPaginator, nameof(defaultPaginator));
return(new SpotifyClientConfig(
BaseAddress,
Authenticator,
JSONSerializer,
HTTPClient,
RetryHandler,
HTTPLogger,
defaultPaginator
));
}
public static bool IsPageValid(IPaginator paginator, List <IEntityBase> entities)
{
if (paginator.ItemsPerPage * paginator.Page > entities.Count && paginator.Page == 1)
{
return(true);
}
else if (paginator.ItemsPerPage * paginator.Page > entities.Count && paginator.Page > 1)
{
return(false);
}
else
{
return(paginator.ItemsPerPage * paginator.Page <= entities.Count);
}
}
/// <summary>
/// Получение текущего объекта пейджера
/// </summary>
public SortedDictionary <int, string> NavBlock(IPaginator paginator)
{
var pVal = new PagerLine
(
size: _uiPaginatorSize,
current: paginator.CurrentPage,
total: paginator.TotalPages
);
var temp = new SortedDictionary <int, string>();
foreach (int item in pVal.PageArr)
{
temp.Add(item, NavActive(paginator.CurrentPage == item));
}
return(temp);
}
/// <summary>
/// This config spefies the internal parts of the SpotifyClient.
/// </summary>
/// <param name="baseAddress"></param>
/// <param name="authenticator"></param>
/// <param name="jsonSerializer"></param>
/// <param name="httpClient"></param>
/// <param name="retryHandler"></param>
/// <param name="httpLogger"></param>
/// <param name="defaultPaginator"></param>
public SpotifyClientConfig(
Uri baseAddress,
IAuthenticator?authenticator,
IJSONSerializer jsonSerializer,
IHTTPClient httpClient,
IRetryHandler?retryHandler,
IHTTPLogger?httpLogger,
IPaginator defaultPaginator
)
{
BaseAddress = baseAddress;
Authenticator = authenticator;
JSONSerializer = jsonSerializer;
HTTPClient = httpClient;
RetryHandler = retryHandler;
HTTPLogger = httpLogger;
DefaultPaginator = defaultPaginator;
}
private static void AttachPaginator(IPaginator paginator, DataGrid dataGrid)
{
var subscription = new SingleAssignmentDisposable();
SetPaginatorSubscription(dataGrid, subscription);
var onPropertyChanged =
new PropertyChangedEventHandler((sender, e) => UpdateByPaginator(dataGrid));
dataGrid.ItemsSource = paginator.CreateReactiveList();
dataGrid.Sorting += OnDataGridSorting;
paginator.PropertyChanged += onPropertyChanged;
subscription.Disposable = Disposable.Create(() =>
{
dataGrid.ItemsSource = Array.Empty <object>();
dataGrid.Sorting -= OnDataGridSorting;
paginator.PropertyChanged -= onPropertyChanged;
});
UpdateByPaginator(dataGrid);
}
public HtmlPaginationRender(IPaginator paginator)
{
_paginator = paginator;
}
public GetExamplePageQueryHandler(IReadOnlyRepository readOnlyRepository, IMapper mapper, IPaginator paginator)
{
_readOnlyRepository = readOnlyRepository;
_mapper = mapper;
_paginator = paginator;
}
public PatronServiceBuilder WithPaginator(IPaginator <Patron> paginator)
{
Paginator = paginator;
return(this);
}
public TagsController(ITagService tagService, IMappingService mappingService, IPaginator paginator)
: base(mappingService)
{
this.tagService = tagService ?? throw new ArgumentNullException();
this.paginator = paginator ?? throw new ArgumentNullException();
}
/// <summary>
/// Create a PaginatedResultKeyResponse by providing any operation paginator
/// and a selector function for the result key
/// </summary>
/// <param name="paginator"></param>
/// <param name="resultKeySelector"></param>
public PaginatedResultKeyResponse(IPaginator <TResponse> paginator, Func <TResponse, IEnumerable <TResultKey> > resultKeySelector)
{
this._paginator = paginator;
this._resultKeySelector = resultKeySelector;
}
/// <summary>Finds a collection of all pages.</summary>
/// <param name="instance">The instance of <see cref="IPaginator{T}"/> that provides the pages.</param>
/// <param name="pageCount">The number of pages to get.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> that provides cancellation support.</param>
/// <typeparam name="T">The type of elements on the page.</typeparam>
/// <returns>A collection of pages.</returns>
public static IEnumerable <Task <ICollectionPage <T> > > FindAllPagesAsync <T>(this IPaginator <T> instance, int pageCount, CancellationToken cancellationToken)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
for (var pageIndex = 0; pageIndex < pageCount; pageIndex++)
{
yield return(instance.FindPageAsync(pageIndex, cancellationToken));
}
}
