/// <summary>
/// 分页
/// </summary>
/// <param name="t"></param>
public PagerViewModel <T> GetPageList(TViewModel viewModel, QueryTermViewModel queryTermViewModel, IDbConnection conn = null, IDbTransaction tran = null)
{
return(CommonAction <BaseViewModel, PagerViewModel <T> >(viewModel, conn, tran, (o, con, tr) =>
{
if (null == queryTermViewModel.SortList || queryTermViewModel.SortList.Count == 0)
{
queryTermViewModel.SortList = new List <ISort>()
{
new Sort()
{
Ascending = false, PropertyName = "ID"
}
};
}
var list = con.GetPage <T>(queryTermViewModel.PredGroup, queryTermViewModel.SortList, viewModel.PageIndex - 1, viewModel.PageCount, tr);
var count = con.Count <T>(queryTermViewModel.PredGroup, tr);
var pager = new PagerViewModel <T>()
{
TotalCount = count
};
if (null != list)
{
pager.ItemList = list.ToList <T>();
}
return pager;
}));
}
public ActionResult SearchProduct(string key, int?page)
{
ViewBag.Context = HttpContext;
var langId = ATICurrentSession.GetLang;
ViewBag.CommonInfo = db.CommonInfoes.FirstOrDefault(c => c.LangId == langId);
AddLog(HttpContext.Session.SessionID);
key = Common.UCS2Convert(key).ToLower();
var listProducts = new List <Product>();
if (string.IsNullOrEmpty(key))
{
listProducts = new List <Product>();
}
else
{
listProducts = db.Products.Where(m => m.UnsignName.Contains(key) && m.Status == 1 && m.LangId == langId && !m.IsDelete).ToList();
}
var pager = new Pager(listProducts.Count(), page);
var viewModel = new PagerViewModel <Product>
{
Items = listProducts.OrderBy(m => m.OrderNo).Skip((pager.CurrentPage - 1) * pager.PageSize).Take(pager.PageSize).ToList(),
Pager = pager
};
return(View(viewModel));
}
public PagerViewModel <T, E> ConstructViewModel(IEnumerable <T> items, int?currentPage, E sortOrder)
{
if (!typeof(E).IsEnum)
{
throw new InvalidCastException("PaginationHandler::ConstructViewModel(): Not an enum!");
}
try
{
dynamic value = sortOrder;
var convertedSortOrder = (Int32)value;
items = Sort(items, convertedSortOrder);
}
catch
{
throw;
}
var pager = new Pager(items.Count(), currentPage);
var viewModel = new PagerViewModel <T, E>
{
Items = items.Skip((pager.CurrentPage - 1) * pager.PageSize).Take(pager.PageSize),
Pager = pager,
SortOrder = sortOrder
};
return(viewModel);
}
/// <summary>
/// 联合查询 分页
/// </summary>
/// <param name="viewModel"></param>
/// <returns></returns>
public static PagerViewModel <T> GetPageList <T>(SQLViewModel viewModel) where T : class, new()
{
using (var conn = SingleHepler <ConnectionFactory> .Instance.CreateConnection())
{
return(conn.QueryAsync <T>(viewModel.SQLStr, viewModel.Params).ContinueWith((task) =>
{
var returnData = task.Result;
var totalCount = 0;
var totalResult = conn.ExecuteReaderAsync(viewModel.CounSQLStr, viewModel.PageCount).Result;
if (totalResult.Read())
{
totalCount = Convert.ToInt32(totalResult["TotalCount"]);
}
var pager = new PagerViewModel <T>()
{
TotalCount = totalCount
};
if (null != returnData)
{
pager.ItemList = returnData.ToList <T>();
}
return pager;
}).Result);
}
}
public static void Clear()
{
Pager = new PagerViewModel();
Pager.CurrentPage = 1;
Pager.PagesCount = 1;
Pager.PageSize = 5;
}
public ActionResult News(string seolink, int?page)
{
var lang = ATICurrentSession.GetLang;
ViewBag.Context = HttpContext;
ViewBag.CommonInfo = db.CommonInfoes.Where(x => x.LangId == lang).FirstOrDefault();
ViewBag.Partners = db.Partners.Where(x => x.LangId == lang).ToList();
AddLog(HttpContext.Session.SessionID);
var cate = db.CateNews.FirstOrDefault(item => item.SeoLink.ToLower().Equals(seolink.ToLower()) && item.Type == 0);
if (cate == null)
{
return(View("FileNotFound"));
}
var viewModel = new PagerViewModel <News>();
var items = db.News.Where(m => m.LangId == lang && m.Type == 0 && m.CateId == cate.ID && m.Status == 1);
var pager = new Pager(items.Count(), page);
viewModel.Items = items.OrderByDescending(m => m.ID).Skip((pager.CurrentPage - 1) * pager.PageSize).Take(pager.PageSize);
viewModel.Pager = new Pager(items.Count(), page);
ViewBag.Cate = cate;
return(View(viewModel));
}
public void ShouldDisplayPrevAndNextIfMiddle()
{
var vm = new PagerViewModel(
totalItems: 77,
itemsPerPage: 25,
currentPage: 2,
captionFormat: "{0} to {1} of {2}",
routeName: "route name",
otherRouteValues: new Dictionary <string, string> {
{ "filter", "Live" }
});
vm.ShowPager.Should().BeTrue();
vm.ShowNext.Should().BeTrue();
vm.CurrentPage.Should().Be(2);
vm.Caption.Should().Be("26 to 50 of 77");
vm.ShowPrevious.Should().BeTrue();
vm.TotalPages.Should().Be(4);
vm.RouteName.Should().Be("route name");
vm.NextPageRouteData.Count.Should().Be(2);
vm.NextPageRouteData["filter"].Should().Be("Live");
vm.NextPageRouteData["page"].Should().Be("3");
vm.PreviousPageRouteData.Count.Should().Be(2);
vm.PreviousPageRouteData["filter"].Should().Be("Live");
vm.PreviousPageRouteData["page"].Should().Be("1");
}
private void TryStorePaginationUrls(PagerViewModel model)
{
string nextUrl;
if (model.CurrentPage > 0 && model.CurrentPage < model.PagerNodes.Count)
{
nextUrl = ContentPagerController.PageNodeUrl(model.PagerNodes[model.CurrentPage], model.RedirectUrlTemplate);
}
else
{
nextUrl = null;
}
string previousUrl;
if (model.CurrentPage > 1)
{
previousUrl = ContentPagerController.PageNodeUrl(model.PagerNodes[model.CurrentPage - 2], model.RedirectUrlTemplate);
}
else
{
previousUrl = null;
}
var paginationUrls = ContentPagerController.GetPaginationUrls(nextUrl, previousUrl);
var page = this.HttpContext.Handler.GetPageHandler();
ContentPagerController.GetTryStorePaginationUrlsMethod().Invoke(null, new object[] { page, paginationUrls });
}
public string RenderToString(PagerViewModel model)
{
StringBuilder sb = new StringBuilder();
Render(sb, model);
return(sb.ToString());
}
public void PagerViewModel_ShouldCalculatePagesCorrectly(int itemsCount, int pageSize, int expected)
{
// Arrange & Act
var model = new PagerViewModel("SomeName", 1, itemsCount, pageSize);
// Assert
Assert.AreEqual(expected, model.PagesCount);
}
private string IsCurrentPage(int page, PagerViewModel model)
{
if (page == model.CurrentPage)
{
return("current");
}
return(string.Empty);
}
public async Task <VacanciesViewModel> GetVacanciesViewModelAsync(
VacancyUser user, string filter, int page, string searchTerm)
{
var getDashboardTask = _providerVacancyClient.GetDashboardAsync(user.Ukprn.Value, createIfNonExistent: true);
var getUserDetailsTask = _recruitVacancyClient.GetUsersDetailsAsync(user.UserId);
var providerTask = _providerRelationshipsService.GetLegalEntitiesForProviderAsync(user.Ukprn.Value, OperationType.RecruitmentRequiresReview);
await Task.WhenAll(getDashboardTask, getUserDetailsTask, providerTask);
var dashboard = getDashboardTask.Result;
var userDetails = getUserDetailsTask.Result;
var providerPermissions = providerTask.Result;
var alerts = _providerAlertsViewModelFactory.Create(dashboard, userDetails);
var vacancies = new List <VacancySummary>(dashboard?.Vacancies ?? Array.Empty <VacancySummary>());
var filteringOption = SanitizeFilter(filter);
var filteredVacancies = GetFilteredVacancies(vacancies, filteringOption, searchTerm);
var filteredVacanciesTotal = filteredVacancies.Count();
page = SanitizePage(page, filteredVacanciesTotal);
var skip = (page - 1) * VacanciesPerPage;
var vacanciesVm = filteredVacancies
.Skip(skip)
.Take(VacanciesPerPage)
.Select(VacancySummaryMapper.ConvertToVacancySummaryViewModel)
.ToList();
var pager = new PagerViewModel(
filteredVacanciesTotal,
VacanciesPerPage,
page,
"Showing {0} to {1} of {2} vacancies",
RouteNames.Vacancies_Get,
new Dictionary <string, string>
{
{ "filter", filteringOption.ToString() },
{ "searchTerm", searchTerm }
});
var vm = new VacanciesViewModel
{
Vacancies = vacanciesVm,
Pager = pager,
Filter = filteringOption,
SearchTerm = searchTerm,
ResultsHeading = VacancyFilterHeadingHelper.GetFilterHeading(Constants.VacancyTerm, filteredVacanciesTotal, filteringOption, searchTerm, UserType.Provider),
Alerts = alerts,
HasEmployerReviewPermission = providerPermissions.Any()
};
return(vm);
}
public static MvcHtmlString Pager(this HtmlHelper helper, int pageIndex, int pageCount, int totalCount, string identify)
{
PagerViewModel model = new PagerViewModel()
{
PageIndex = pageIndex, PageCount = pageCount, Identify = identify, TotalCount = totalCount
};
return(helper.Partial("Pager", model));
}
public IActionResult ManageArticles(int pageIndex = 1, int pageSize = 5)
{
int itemsCount = _articlesRepository.GetArticleCount();
string controller = nameof(ManageArticlesController);
string action = nameof(this.ManageArticles);
var model = new PagerViewModel(itemsCount, pageSize, pageIndex, controller, action);
return(View(model));
}
public override void Load()
{
try
{
_logger.LogDebug("Load {0}", _debugName);
BeforeLoad();
PagingResultDto <T1> result;
var qe = new QueryBuilder.QueryExpression()
{
PageIndex = PagerViewModel.CurrentPageIndex,
PageSize = PagerViewModel.PageSize,
WhereOptions = WhereOptionsFromHeaderFilter(HeaderFilters),
OrderOptions = OrderOptionsFromHeaderFilter(HeaderFilters)
};
result = DataService.Get <T, T1>(qe);
_originalEntities.Clear();
foreach (var dto in result.Items)
{
ProcessDataModelBeforeAddToEntities(dto);
_originalEntities.Add(dto);
}
Entities.Reset(result.Items);
PagerViewModel.ItemCount = Entities.Count;
PagerViewModel.PageCount = result.PageCount;
PagerViewModel.SetCurrentPageIndexWithoutAction(result.PageIndex);
AfterLoad();
SysMsg = "OK";
}
catch (System.Net.WebException ex)
{
if (ex.Response != null)
{
var statusCode = ((System.Net.HttpWebResponse)ex.Response).StatusCode;
SysMsg = string.Format("[{0}] {1}", statusCode, new System.IO.StreamReader(ex.Response.GetResponseStream()).ReadToEnd());
}
else
{
SysMsg = ex.Message;
}
}
catch (Exception ex)
{
SysMsg = ex.Message;
}
}
public async Task <IViewComponentResult> InvokeAsync(
int page,
int count)
{
var model = new PagerViewModel()
{
Page = page,
PageCount = count
};
return(View(model));
}
public void ShouldNotDisplayIfLessThanOnePageOfResults()
{
var vm = new PagerViewModel(
totalItems: 25,
itemsPerPage: 25,
currentPage: 1,
captionFormat: "{0} to {1} of {2}",
routeName: "route name",
otherRouteValues: null);
vm.ShowPager.Should().BeFalse();
}
public PartialViewResult Index(int currentPage, int totalPagesCount, string redirectUrlTemplate)
{
var model = new PagerViewModel(currentPage, totalPagesCount, redirectUrlTemplate);
// Build the pager
int startIndex = 1;
if (model.CurrentPage > model.DisplayCount)
{
if (model.CurrentPage <= 0)
{
model.CurrentPage = 1;
}
startIndex = ((int)Math.Floor((double)(model.CurrentPage - 1) / model.DisplayCount) * model.DisplayCount) + 1;
model.CurrentPage %= model.DisplayCount;
}
int endIndex = Math.Min(model.TotalPagesCount, (startIndex + model.DisplayCount) - 1);
// Check to see if we need a Previous Button Node
if (startIndex > model.DisplayCount)
{
model.PreviousNode = new Pager.PagerNumericItem(Math.Max(startIndex - 1, 1));
}
else
{
model.PreviousNode = null;
}
for (int i = startIndex; i <= endIndex; i++)
{
var text = string.Format(model.RedirectUrlTemplate, i);
Pager.PagerNumericItem pagerNumericItem = new Pager.PagerNumericItem(i, text);
model.PagerNodes.Add(pagerNumericItem);
}
// Check to see if we need a Next Button Node
if (endIndex < model.TotalPagesCount)
{
model.NextNode = new Pager.PagerNumericItem(endIndex + 1);
}
else
{
model.NextNode = null;
}
this.TryStorePaginationUrls(model);
return(this.PartialView("Pager", model));
}
public ActionResult Product(string seolink, int?page)
{
ViewBag.Context = HttpContext;
var langId = ATICurrentSession.GetLang;
ViewBag.CommonInfo = db.CommonInfoes.Where(x => x.LangId == langId).FirstOrDefault();
AddLog(HttpContext.Session.SessionID);
var currentCate = db.CateProducts.FirstOrDefault(item => item.SeoLink.Equals(seolink.ToLower()) && item.LangId == langId);
if (currentCate == null)
{
return(View("FileNotFound"));
}
ViewBag.Cate = currentCate;
var cateChilds = db.CateProducts.Where(m => !m.IsDelete && m.ParrentCateId == currentCate.ID && m.LangId == langId).ToList();
var products = new PagerViewModel <Product>();
if (cateChilds != null && cateChilds.Count() > 0)
{
var cateChildsSearch = new List <int>();
var cateChildIds = cateChilds.Select(m => m.ID).ToList();
cateChildsSearch.AddRange(cateChildIds);
foreach (var item in cateChildIds)
{
var cateChilds1 = db.CateProducts.Where(m => !m.IsDelete && m.ParrentCateId == item && m.LangId == langId).ToList();
if (cateChilds1 != null && cateChilds1.Count() > 0)
{
cateChildsSearch.AddRange(cateChilds1.Select(m => m.ID));
}
}
cateChildsSearch.Add(currentCate.ID);
var items = db.Products.Where(m => !m.IsDelete && m.LangId == langId && m.Status == 1 && cateChildsSearch.Contains(m.CateId));
var pager = new Pager(items.Count(), page);
products.Items = items.OrderBy(m => m.OrderNo).Skip((pager.CurrentPage - 1) * pager.PageSize).Take(pager.PageSize);
products.Pager = new Pager(items.Count(), page);
}
else
{
var items = db.Products.Where(m => !m.IsDelete && m.LangId == langId && m.Status == 1 && m.CateId == currentCate.ID);
var pager = new Pager(items.Count(), page);
products.Items = items.OrderBy(m => m.OrderNo).Skip((pager.CurrentPage - 1) * pager.PageSize).Take(pager.PageSize);
products.Pager = new Pager(items.Count(), page);
}
return(View(products));
}
private void TryStorePaginationUrls(PagerViewModel model)
{
string nextUrl;
var highlightedIndex = model.CurrentPage % model.DisplayCount;
if (highlightedIndex == 0)
{
highlightedIndex = model.DisplayCount;
}
if (model.CurrentPage > 0 && model.CurrentPage < model.TotalPagesCount)
{
if (highlightedIndex == model.DisplayCount)
{
nextUrl = ContentPagerController.PageNodeUrl(model.NextNode, model.RedirectUrlTemplate);
}
else
{
nextUrl = ContentPagerController.PageNodeUrl(model.PagerNodes[highlightedIndex], model.RedirectUrlTemplate);
}
}
else
{
nextUrl = null;
}
string previousUrl;
if (model.CurrentPage > 1)
{
if (highlightedIndex > 1)
{
previousUrl = ContentPagerController.PageNodeUrl(model.PagerNodes[highlightedIndex - 2], model.RedirectUrlTemplate);
}
else
{
previousUrl = ContentPagerController.PageNodeUrl(model.PreviousNode, model.RedirectUrlTemplate);
}
}
else
{
previousUrl = null;
}
var paginationUrls = ContentPagerController.GetPaginationUrls(nextUrl, previousUrl);
var page = this.HttpContext.Handler.GetPageHandler();
ContentPagerController.GetTryStorePaginationUrlsMethod().Invoke(null, new object[] { page, paginationUrls });
}
public async Task <DashboardViewModel> GetDashboardViewModelAsync(string employerAccountId, string filter, int page, VacancyUser user, string searchTerm)
{
var vacanciesTask = GetVacanciesAsync(employerAccountId);
var userDetailsTask = _client.GetUsersDetailsAsync(user.UserId);
await Task.WhenAll(vacanciesTask, userDetailsTask);
var vacancies = vacanciesTask.Result;
var userDetails = userDetailsTask.Result;
var filteringOption = SanitizeFilter(filter);
var filteredVacancies = GetFilteredVacancies(vacancies, filteringOption, searchTerm);
var filteredVacanciesTotal = filteredVacancies.Count();
page = SanitizePage(page, filteredVacanciesTotal);
var skip = (page - 1) * VacanciesPerPage;
var vacanciesVm = filteredVacancies
.Skip(skip)
.Take(VacanciesPerPage)
.Select(VacancySummaryMapper.ConvertToVacancySummaryViewModel)
.ToList();
var pager = new PagerViewModel(
filteredVacanciesTotal,
VacanciesPerPage,
page,
"Showing {0} to {1} of {2} vacancies",
RouteNames.Dashboard_Index_Get,
new Dictionary <string, string>
{
{ "filter", filteringOption.ToString() },
{ "searchTerm", searchTerm }
});
var vm = new DashboardViewModel {
Vacancies = vacanciesVm,
Pager = pager,
Filter = filteringOption,
SearchTerm = searchTerm,
ResultsHeading = GetFilterHeading(filteredVacanciesTotal, filteringOption, searchTerm),
HasVacancies = vacancies.Any(),
Alerts = GetAlerts(vacancies, userDetails)
};
return(vm);
}
public IActionResult ManageProducts(int pageIndex, int pageSize)
{
try
{
string controller = nameof(ManageStoreController);
string action = nameof(this.ManageProducts);
int count = _storeRepository.GetProductCount();
var model = new PagerViewModel(count, pageSize, pageIndex, controller, action);
return(View(model));
}
catch
{
return(View());
}
}
public ActionResult<IEnumerable<ApplicationUser>> GetUsers([FromQuery]PagerViewModel viewModel)
{
var model = new
{
Data = _mapper.Map<IEnumerable<ApplicationUser>, IEnumerable<SelectUserViewModel>>(_user.Users
.OrderBy(a => a.Id)
.Skip(viewModel.PageSize *viewModel.Start)
.Take(viewModel.PageSize)
.ToList()),
TotalCount = _user.Users.Count()
};
return Ok(model);
}
private void SetPager(string searchTerm, int page, LegalEntityViewModel vm, int filteredLegalEntitiesTotal)
{
var pager = new PagerViewModel(
filteredLegalEntitiesTotal,
MaxLegalEntitiesPerPage,
page,
"Showing {0} to {1} of {2} organisations",
RouteNames.LegalEntity_Get,
new Dictionary <string, string>
{
{ nameof(searchTerm), searchTerm }
});
vm.Pager = pager;
}
public ActionResult Service(int?page)
{
ViewBag.Context = HttpContext;
var lang = ATICurrentSession.GetLang;
ViewBag.CommonInfo = db.CommonInfoes.Where(x => x.LangId == lang).FirstOrDefault();
AddLog(HttpContext.Session.SessionID);
var viewModel = new PagerViewModel <Partner>();
var items = db.Partners.Where(x => x.LangId == lang);
var pager = new Pager(items.Count(), page);
viewModel.Items = items.OrderBy(m => m.OrderNo).Skip((pager.CurrentPage - 1) * pager.PageSize).Take(pager.PageSize);
viewModel.Pager = new Pager(items.Count(), page);
return(View(viewModel));
}
public void Render(StringBuilder sb, PagerViewModel model)
{
if (model.TotalPages <= 1)
{
return;
}
int pages = model.TotalPages;
sb.Append("<div class=\"pager\">");
sb.Append("<ul>");
sb.Append("<li><a href=\"" + String.Format(model.PagerUrlFormatFirst, 1) + "\">|<</a></li>");
if (model.CurrentPage > 1)
{
sb.Append("<li><a href=\"" + String.Format(model.PagerUrlFormat, model.CurrentPage - 1) + "\">«</a></li>");
}
else
{
sb.Append("<li class=\"inactive\"> </li>");
}
for (int i = 1; i <= pages; i++)
{
sb.Append("<li class=\"" + IsCurrentPage(i, model) + "\">");
if (i == 1)
{
sb.Append("<a href=\"" + String.Format(model.PagerUrlFormatFirst, i) + "\">" + i + "</a>");
}
else
{
sb.Append("<a href=\"" + String.Format(model.PagerUrlFormat, i) + "\">" + i + "</a>");
}
sb.Append("</li>");
}
if (model.CurrentPage < pages)
{
sb.Append("<li><a href=\"" + String.Format(model.PagerUrlFormat, model.CurrentPage + 1) + "\">»</a></li>");
}
else
{
sb.Append("<li class=\"inactive\"> </li>");
}
sb.Append("<li><a href=\"" + String.Format(model.PagerUrlFormat, pages) + "\">>|</a></li>");
sb.Append("</ul>");
sb.Append("</div>");
}
public override void Load()
{
var qe = new QueryExpression()
{
PageIndex = PagerViewModel.CurrentPageIndex,
PageSize = PagerViewModel.PageSize,
WhereOptions = WhereOptionsFromHeaderFilter(HeaderFilters),
OrderOptions = OrderOptionsFromHeaderFilter(HeaderFilters)
};
var data = QueryExpression.AddQueryExpression(_data.AsQueryable(), ref qe, out int pageCount);
Entities.Reset(data);
PagerViewModel.ItemCount = Entities.Count;
PagerViewModel.PageCount = pageCount;
PagerViewModel.SetCurrentPageIndexWithoutAction(qe.PageIndex);
SysMsg = "OK";
}
public BaseViewModel()
{
_debugName = NameManager.Instance.GetViewModelName <T>();
LoadReferenceData();
Entities = new ObservableCollectionEx <T>();
Entities.CollectionChanged += Entities_CollectionChanged;
HeaderFilters = new List <HeaderFilterBaseModel>();
PagerViewModel = new PagerViewModel()
{
IsEnablePaging = true,
CurrentPageIndex = 1,
ItemCount = 0,
PageCount = 0
};
PagerViewModel.ActionCurrentPageIndexChanged = Load;
PagerViewModel.ActionIsEnablePagingChanged = Load;
SelectedValuePath = nameof(DTO.IDto.ID);
}
public async Task <IActionResult> Index(int page = 1, int size = 10, string orderBy = "Name", bool order = true)
{
try
{
var cinemas = await cinemaService.GetPagedAsync(page - 1, size, orderBy, order);
var count = await cinemaService.GetCountAsync();
var dto = new PagerViewModel <CinemaIndexViewModel>()
{
Items = mapper.Map <List <CinemaIndexViewModel> >(cinemas),
Pager = new Pager(page, size, orderBy, order, count)
};
return(View(dto));
}
catch
{
// TODO: Add proper error page and Log
return(RedirectToAction("Index", "Home"));
}
}
public static void Pager(this PagerViewModel model)
{
model.ViewPageList = new List <PagerElementModel>();
if (model.TotalRecords == 0)
{
return;
}
if (model.ShowPagerItems && (model.TotalPages > 1))
{
if (model.ShowIndividualPages)
{
//individual pages
var firstIndividualPageIndex = model.GetFirstIndividualPageIndex();
var lastIndividualPageIndex = model.GetLastIndividualPageIndex();
for (var i = firstIndividualPageIndex; i <= lastIndividualPageIndex; i++)
{
if (model.PageIndex == i)
{
model.ViewPageList.Add(
new PagerElementModel()
{
Index = model.PageIndex + 1,
IsActive = true
});
}
else
{
model.ViewPageList.Add(new PagerElementModel()
{
Index = (i + 1),
IsActive = false
});
}
}
}
}
}
public override void Close()
{
base.Close();
deleteOfficeCommand = null;
viewOfficeCommand = null;
editOfficeCommand = null;
newOfficeCommand = null;
pagerViewModel = null;
officeList = null;
senatorService = null;
search = null;
_systemLogService = null;
Senator = null;
senators = null;
}
