/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
#region LIST
//----------------------------------------------------------------------------------------------------------------------------------
// LIST
//----------------------------------------------------------------------------------------------------------------------------------
public questStatus List(out GroupsListViewModel groupsListViewModel)
{
// Initialize
questStatus status = null;
groupsListViewModel = null;
// Get query options from query string
QueryOptions queryOptions = null;
BaseListModeler baseListModeler = new BaseListModeler(this.HttpRequestBase, new UserSession());
status = baseListModeler.ParsePagingOptions(this.HttpRequestBase, out queryOptions);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Set up query options.
// TEMPORARY: OPTIMIZE THIS
List <SearchField> searchFieldList = new List <SearchField>();
SearchOptions searchOptions = new SearchOptions();
searchOptions.SearchFieldList = searchFieldList;
queryOptions.SearchOptions = searchOptions;
// List
status = List(queryOptions, out groupsListViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public void Can_Paginate()
{
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
Mock <IGenericRepository <Group> > mockR = new Mock <IGenericRepository <Group> >();
mockR.Setup(r => r.GetAll()).Returns(() => new Group[]
{
new Group {
ID = 1, Name = "N1"
},
new Group {
ID = 2, Name = "N2"
},
new Group {
ID = 3, Name = "N3"
},
new Group {
ID = 4, Name = "N4"
},
new Group {
ID = 5, Name = "N5"
}
}.AsQueryable());
mock.Setup(u => u.Groups).Returns(mockR.Object);
GroupController controller = new GroupController(mock.Object);
controller.PageSize = 3;
GroupsListViewModel result = (GroupsListViewModel)controller.List(2).Model;
Group[] groupArray = result.Groups.ToArray();
Assert.IsTrue(groupArray.Length == 2);
Assert.AreEqual(groupArray[0].Name, "N4");
Assert.AreEqual(groupArray[1].Name, "N5");
}
public IActionResult List()
{
string userId = this.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
GroupsListViewModel viewModel = this.groupsService.ListAllGroupsForUser(userId);
return(this.View(viewModel));
}
public ActionResult Index(BaseUserSessionViewModel baseUserSessionViewModel)
{
questStatus status = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
baseUserSessionViewModel.questStatus = status;
return(View("Index", baseUserSessionViewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(baseUserSessionViewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
baseUserSessionViewModel.questStatus = status;
return(View("Index", baseUserSessionViewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return view.
*---------------------------------------------------------------------------------------------------------------------------------*/
GroupsListViewModel tablesetsListViewModel = new GroupsListViewModel(this.UserSession, baseUserSessionViewModel);
return(View(tablesetsListViewModel));
}
public AddGroup(int userId, UnitOfWork repo)
{
repository = repo;
InitializeComponent();
this.CurrentUser = repository.Users.FindBy(u => u.UserID == userId).SingleOrDefault();
LoadGroup();
var viewmodel = new GroupsListViewModel(this.CurrentUser.UserGroups.ToList());
usergroupbindingSource.DataSource = viewmodel.Grouplist;
}
/// <summary>
/// Конструктор.
/// </summary>
internal GroupsPage(IRepository <Group, Guid> groupsStore, IPath path, ILogManager logManager, PageCreator pageCreator)
{
InitializeComponent();
_pageCreator = pageCreator;
_viewModel = new GroupsListViewModel(groupsStore, path, logManager);
_logger = logManager.GetLog();
BindingContext = _viewModel;
_viewModel.PushPage += OnPushPage;
}
protected override void HandleOnNavigatedTo(NavigationEventArgs e)
{
base.HandleOnNavigatedTo(e);
if (!this._isInitialized)
{
string str = "";
if (((Page)this).NavigationContext.QueryString.ContainsKey("Name"))
{
str = ((Page)this).NavigationContext.QueryString["Name"];
}
this._pickManaged = ((Page)this).NavigationContext.QueryString["PickManaged"] == bool.TrueString;
this._shareContentDataProvider = ShareContentDataProviderManager.RetrieveDataProvider();
this._excludedId = long.Parse(((Page)this).NavigationContext.QueryString["ExcludedId"]);
this._ownerId = long.Parse(((Page)this).NavigationContext.QueryString["OwnerId"]);
this._picId = long.Parse(((Page)this).NavigationContext.QueryString["PicId"]);
this._isGif = bool.Parse(((Page)this).NavigationContext.QueryString["IsGif"]);
this._accessKey = ((Page)this).NavigationContext.QueryString["AccessKey"];
if (this._shareContentDataProvider is ShareExternalContentDataProvider)
{
((Page)this).NavigationService.ClearBackStack();
}
long userId = this.CommonParameters.UserId;
string userName = str;
int num = this._pickManaged ? 1 : 0;
long excludedId = this._excludedId;
GroupsListViewModel groupsListViewModel = new GroupsListViewModel(userId, userName, num != 0, excludedId);
base.DataContext = ((object)groupsListViewModel);
if (!this._pickManaged && this._shareContentDataProvider == null)
{
groupsListViewModel.AllVM.LoadData(false, false, (Action <BackendResult <VKList <Group>, ResultCode> >)null, false);
}
else
{
this.Header.HideSandwitchButton = true;
this.SuppressMenu = true;
((PresentationFrameworkCollection <object>)((ItemsControl)this.pivot).Items).Remove((object)this.pivotItemAll);
((PresentationFrameworkCollection <object>)((ItemsControl)this.pivot).Items).Remove((object)this.pivotItemEvents);
}
long loggedInUserId = AppGlobalStateManager.Current.LoggedInUserId;
if (userId != loggedInUserId)
{
((PresentationFrameworkCollection <object>)((ItemsControl)this.pivot).Items).Remove((object)this.pivotItemManage);
}
this._isInitialized = true;
}
if (this._dialogService == null || !this._dialogService.IsOpen)
{
this.UpdateAppBar();
}
this._text = ParametersRepository.GetParameterForIdAndReset("ShareText") as string;
}
public ActionResult Next(GroupsListViewModel groupsListViewModel)
{
questStatus status = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
status = new questStatus(Severity.Success);
groupsListViewModel.questStatus = status;
return(Json(groupsListViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(groupsListViewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
status = new questStatus(Severity.Success);
groupsListViewModel.questStatus = status;
return(Json(groupsListViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Get list of items.
*---------------------------------------------------------------------------------------------------------------------------------*/
// TODO.
GroupsListViewModel tablesetsListViewModelNEW = null;
GroupsListModeler groupsListModeler = new GroupsListModeler(this.Request, this.UserSession);
status = groupsListModeler.List(out tablesetsListViewModelNEW);
if (!questStatusDef.IsSuccess(status))
{
status = new questStatus(Severity.Success);
groupsListViewModel.questStatus = status;
return(Json(groupsListViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return view
*---------------------------------------------------------------------------------------------------------------------------------*/
status = new questStatus(Severity.Success);
tablesetsListViewModelNEW.questStatus = status;
return(Json(tablesetsListViewModelNEW, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> ByGenre(int?pageNumber, int id)
{
var groupsInfo = this.groupsService.GetGroupsByGenreId <GroupInfoViewModel>(id);
var groups = await PaginatedList <GroupInfoViewModel>
.CreateAsync(groupsInfo, pageNumber ?? GlobalConstants.DefaultPageNumber, GlobalConstants.PageSize);
var genreName = await this.genresService.GetNameByIdAsync(id);
var viewModel = new GroupsListViewModel
{
GenreName = genreName,
Groups = groups,
};
return(this.View(viewModel));
}
public ViewResult List(int page = 1)
{
GroupsListViewModel model = new GroupsListViewModel
{
Groups = unitOfWork.Groups.GetAll()
.OrderBy(o => o.Name).ToList()
.Skip((page - 1) * PageSize)
.Take(PageSize),
PagingInfo = new PagingInfo
{
CurrentPage = page,
ItemsPerPage = PageSize,
TotalItems = unitOfWork.Groups.GetAll().Count()
}
};
return(View(model));
}
public questStatus List(QueryOptions queryOptions, out GroupsListViewModel groupsListViewModel)
{
// Initialize
questStatus status = null;
groupsListViewModel = null;
// List
QueryResponse queryResponse = null;
List <Quest.Functional.ASM.Group> groupList = null;
GroupsMgr groupsMgr = new GroupsMgr(this.UserSession);
status = groupsMgr.List(queryOptions, out groupList, out queryResponse);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Sort
groupList.Sort(delegate(Quest.Functional.ASM.Group i1, Quest.Functional.ASM.Group i2) { return(i1.Name.CompareTo(i2.Name)); });
// Transfer model.
// TODO: USE BaseListModeler to xfer queryOptions to QueryOptionsViewModel.
groupsListViewModel = new GroupsListViewModel(this.UserSession);
QueryResponseViewModel queryResponseViewModel = null;
status = TransferQueryResponse(queryResponse, out queryResponseViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
groupsListViewModel.QueryResponse = queryResponseViewModel;
foreach (Quest.Functional.ASM.Group group in groupList)
{
GroupLineItemViewModel groupLineItemViewModel = new GroupLineItemViewModel();
BufferMgr.TransferBuffer(group, groupLineItemViewModel);
groupsListViewModel.Items.Add(groupLineItemViewModel);
}
return(new questStatus(Severity.Success));
}
public questStatus Page(out GroupsListViewModel groupsListViewModel)
{
// Initialize
questStatus status = null;
groupsListViewModel = null;
// Set up query options.
// TEMPORARY: OPTIMIZE THIS
List <SearchField> searchFieldList = new List <SearchField>();
SearchOptions searchOptions = new SearchOptions();
searchOptions.SearchFieldList = searchFieldList;
QueryOptions queryOptions = new QueryOptions(100, 1);
queryOptions.SearchOptions = searchOptions;
QueryResponse queryResponse = null;
// List
List <Quest.Functional.ASM.Group> groupList = null;
GroupsMgr groupsMgr = new GroupsMgr(this.UserSession);
status = groupsMgr.List(queryOptions, out groupList, out queryResponse);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Transfer model.
groupsListViewModel = new GroupsListViewModel(this.UserSession);
foreach (Quest.Functional.ASM.Group group in groupList)
{
GroupLineItemViewModel groupLineItemViewModel = new GroupLineItemViewModel();
BufferMgr.TransferBuffer(group, groupLineItemViewModel);
groupsListViewModel.Items.Add(groupLineItemViewModel);
}
return(new questStatus(Severity.Success));
}
public async Task <IActionResult> List(CancellationToken cancellationToken)
{
var account = await AccountProvider.GetAccountForCurrentUser(cancellationToken);
var groups = await MailAppDbContext.Groups
.Include(x => x.GroupAccounts).ThenInclude(x => x.Type)
.Include(x => x.GroupAccounts).ThenInclude(x => x.Account)
.ToArrayAsync(cancellationToken);
var viewModel = new GroupsListViewModel
{
Groups = groups
.Where(x => x.IsMember(account))
.Select(x => new GroupViewModel
{
GroupId = x.Id,
Name = x.Name
})
.ToArray(),
};
return(View(viewModel));
}
public void Can_Send_Pagination_View_Model()
{
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
Mock <IGenericRepository <Group> > mockR = new Mock <IGenericRepository <Group> >();
mockR.Setup(r => r.GetAll()).Returns(() => new Group[]
{
new Group {
ID = 1, Name = "N1"
},
new Group {
ID = 2, Name = "N2"
},
new Group {
ID = 3, Name = "N3"
},
new Group {
ID = 4, Name = "N4"
},
new Group {
ID = 5, Name = "N5"
}
}.AsQueryable());
mock.Setup(u => u.Groups).Returns(mockR.Object);
GroupController controller = new GroupController(mock.Object);
controller.PageSize = 3;
GroupsListViewModel result = (GroupsListViewModel)controller.List(2).Model;
PagingInfo pageInfo = result.PagingInfo;
Assert.AreEqual(pageInfo.CurrentPage, 2);
Assert.AreEqual(pageInfo.ItemsPerPage, 3);
Assert.AreEqual(pageInfo.TotalItems, 5);
Assert.AreEqual(pageInfo.TotalPages, 2);
}
public GroupsListViewModel ListAllGroupsForUser(string userId)
{
GroupsListViewModel groupsList = new GroupsListViewModel
{
GroupsForUser = this.context.GroupUsers
.Where(gu => gu.IsDeleted == false)
.Where(gu => gu.UserId == userId)
.Select(gu => new GroupUsersListViewModel
{
Id = gu.GroupId,
Name = gu.Group.Name,
}).ToList(),
OwnedGroups = this.context.Groups
.Where(g => g.IsDeleted == false)
.Where(g => g.OwnerId == userId)
.Select(g => new GroupsOwnedByUserViewModel
{
Id = g.Id,
Name = g.Name,
}).ToList(),
};
return(groupsList);
}
