public HttpResponseMessage GetUserCreditsPaginated([FromUri] PaginatedRequest model) { PaginatedItemsResponse <UserCredits> response = _CreditsService.GetTransactionsPaginated(model); return(Request.CreateResponse(HttpStatusCode.OK, response)); }
public async Task <IActionResult> GetData([FromQuery] PaginatedRequest request) { var query = Repository.GetKarma(request.Sort); var data = PaginatedData <KarmaItem> .Create(query, request, entity => new KarmaItem(entity)); var users = await GrillBotService.GetUsersSimpleInfoBatchAsync(data.Data.Select(o => o.UserID)); var position = PaginationHelper.CountSkipValue(request) + 1; foreach (var item in data.Data) { item.User = users.Find(o => o.ID == item.UserID); if (item.User == null) { item.User = SimpleUserInfo.DefaultUser; item.User.ID = item.UserID; } item.Position = position; position++; } data.Data = data.Data.ToList(); return(Ok(data)); }
public async Task<PaginatedResponse<IEnumerable<FriendsInCategoryResponse>>> GetFriendsInCategory(PaginatedRequest<FriendsInCategoryRequest> request, SystemSession session) { var serviceRequest = new UserCategory { UserId = session.UserId.ToString(), UserCategoryTypeId = request.Data.CategoryId, InvertCatSerch = request.Data.InvertCategorySearch, PageIndex = request.PageIndex, PageSize = request.PageSize + 1 }; var data = await Task.Factory.StartNew(() => Client.UserService.getUserFriendsInCategory(serviceRequest, session.GetSession())).ConfigureAwait(false); var result = new PaginatedResponse<IEnumerable<FriendsInCategoryResponse>> { Page = data.Select(x => new FriendsInCategoryResponse { UserId = x.UserId, UserName = x.UserName, Image = x.Picture, FirstName = x.FirstName, LastName = x.LastName, Title = x.Title, UserTypeId = (SystemUserType)x.UserTypeId, Email = x.Email }).Take(request.PageSize), HasNextPage = data.Count > request.PageSize }; return result; }
public void GetAllAsync_GetAllBranchRestrictions_MultipleBranchRestrictionsAreRetrieved() { var paginatedRequest = new PaginatedRequest(); var result = _client.GetAllAsync(_defaultUser, _defaultRepository, paginatedRequest).Result; AssertHelper.AtLeastOnePropertyIsNotDefault <PaginatedResponse <BranchRestriction> >(result); }
public IActionResult Hfeed([FromQuery] HomeFeedRequest model) { HomeFeedReturn ret; Claim idClaim = User.FindFirst("sub"); PaginatedRequest feedReq = new PaginatedRequest() { Order = model.ActivityOrder, PageIndex = model.ActivityPageIndex, PageSize = model.ActivityPageSize }; PaginatedRequest urecReq = new PaginatedRequest() { Order = model.UserRecommendationOrder, PageIndex = model.UserRecommendationPageIndex, PageSize = model.UserRecommendationPageSize }; PaginatedRequest grecReq = new PaginatedRequest() { Order = model.GroupRecommendationsOrder, PageIndex = model.GroupRecommendationsPageIndex, PageSize = model.GroupRecommendationsPageSize }; ret = _feedDataService.GetUserFeed(idClaim?.Value, feedReq, urecReq, grecReq); return(Ok(ret)); }
public async Task<PaginatedResponseExtended<IEnumerable<UserInformationBaseExtendedResponse>, int>> GetMutualFriends(PaginatedRequest<string> request, SystemSession session) { var serviceRequest = new MutualFriend { UserId = session.UserId, TargetType = "F", TargetUser = request.Data, PageIndex = request.PageIndex, PageSize = request.PageSize }; var data = await Task.Factory.StartNew(() => Client.UserService.getMutualFriends(serviceRequest, session.GetSession())).ConfigureAwait(false); var result = new PaginatedResponseExtended<IEnumerable<UserInformationBaseExtendedResponse>, int> { Page = data.MutualFriends.Select(x => new UserInformationBaseExtendedResponse { UserId = x.UserId, UserName = x.UserName, UserTypeId = (SystemUserType)x.UserTypeId, FirstName = x.FirstName, LastName = x.LastName, Image = x.Picture, Title = x.Title }), HasNextPage = data.HasNextPage, Information = data.Count }; return result; }
public async Task<PaginatedResponseExtended<IEnumerable<ViewerDetailResponse>, int>> GetProfileViewDetail(PaginatedRequest<GeneralKvPair<SystemProfileViewType, int>> request, SystemSession session) { var serviceRequest = new ProfileView { UserId = request.UserId, ViewType = (byte)request.Data.Id, TypeId = request.Data.Value, PageIndex = request.PageIndex, PageSize = request.PageSize }; var response = await Task.Factory.StartNew(() => Client.UserService.profileViewDetail(serviceRequest, session.GetSession())).ConfigureAwait(false); var data = response.ProfileViews.Select(x => new ViewerDetailResponse { UserId = x.UserId, UserTypeId = (SystemUserType)x.UserTypeId, UserName = x.Username, FirstName = x.FirstName, LastName = x.LastName, Image = x.Picture, FriendshipStatus = (SystemFriendshipStatus)x.IsConnected, Observed = x.Observed, Title = x.Title, ViewedDate = Convert.ToDateTime(x.ViewDate) }); var result = new PaginatedResponseExtended<IEnumerable<ViewerDetailResponse>, int> { Page = data, HasNextPage = response.HasNextPage, Information = response.ViewCount }; return result; }
public HomeFeedReturn GetUserFeed(string currUserId, PaginatedRequest feedReq, PaginatedRequest urecReq, PaginatedRequest grecReq) { HomeFeedReturn ret = new HomeFeedReturn(); bool isLoggedIn = !string.IsNullOrEmpty(currUserId); if (!isLoggedIn) { ret.ErrorCode = "401"; return(ret); } GetUserLikes(currUserId); string[] followingUserIds = currentUserFollowings.Where(p => p.Value == FollowState.Confirmed).Select(p => p.Key).ToArray(); int totalFollowing = followingUserIds.Count(); if (totalFollowing == 0) { return(ret); } ret.FriendActivities = GetPaginatedUserActivityFeed(currUserId, followingUserIds, feedReq); ret.UserRecommeandations = GetPaginatedUserRecommendations(currUserId, followingUserIds, userGroupFollowIds, urecReq); ret.GroupRecommendations = GetPaginatedGroupRecommendations(currUserId, followingUserIds, userGroupFollowIds, grecReq); return(ret); }
public async Task<PaginatedResponseExtended<IEnumerable<ViewSummaryResponse>, int>> GetProfileViewSummary(PaginatedRequest<int> request, SystemSession session) { var serviceRequest = new ProfileView { UserId = request.UserId, ViewType = request.Data, PageIndex = request.PageIndex, PageSize = request.PageSize }; var response = await Task.Factory.StartNew(() => Client.UserService.profileViewSummary(serviceRequest, session.GetSession())).ConfigureAwait(false); var data = response.ProfileViews.Select(x => new ViewSummaryResponse { TypeId = x.TypeId, Name = x.FirstName, ViewCount = x.ViewersCount, NewViewCount = x.NewViews, LastViewed = Convert.ToDateTime(x.ViewDate) }); var result = new PaginatedResponseExtended<IEnumerable<ViewSummaryResponse>, int> { Page = data, HasNextPage = response.HasNextPage, Information = response.ViewCount }; return result; }
public async Task <ICollection <Part> > GetLowStockAsync(PaginatedRequest request, IUserContext userContext) { var offsetRecords = (request.Page - 1) * request.Results; var sortDirection = request.Direction == SortDirection.Ascending ? "ASC" : "DESC"; var query = $@"SELECT * FROM Parts WHERE Quantity <= LowStockThreshold AND (@UserId IS NULL OR UserId = @UserId) ORDER BY CASE WHEN @OrderBy IS NULL THEN PartId ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'PartNumber' THEN PartNumber ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'DigikeyPartNumber' THEN DigikeyPartNumber ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'MouserPartNumber' THEN MouserPartNumber ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'Cost' THEN Cost ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'Quantity' THEN Quantity ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'LowStockThreshold' THEN LowStockThreshold ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'PartTypeId' THEN PartTypeId ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'ProjectId' THEN ProjectId ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'Location' THEN Location ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'BinNumber' THEN BinNumber ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'BinNumber2' THEN BinNumber2 ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'Manufacturer' THEN Manufacturer ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'ManufacturerPartNumber' THEN ManufacturerPartNumber ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'DateCreatedUtc' THEN DateCreatedUtc ELSE NULL END {sortDirection} OFFSET {offsetRecords} ROWS FETCH NEXT {request.Results} ROWS ONLY;"; var result = await SqlQueryAsync <Part>(query, new { Results = request.Results, Page = request.Page, OrderBy = request.OrderBy, Direction = request.Direction, UserId = userContext?.UserId }); return(result); }
/// <summary> /// Example implementation of List method: lists all entries of type <see cref="Todo"/> /// </summary> /// <returns></returns> public PaginatedResult <IEnumerable <Todo> > List(PaginatedRequest request) { var totalPages = 1; var totalItems = Repository.Count(); var result = Repository.All(); if (!string.IsNullOrEmpty(request.OrderBy)) { result = result.OrderByMember(request.OrderBy, request.Reverse); } else { result = result.OrderByDescending(t => t.CreatedDate); } if (request.NumPerPage > 0) { totalPages = (result.Count() + request.NumPerPage - 1) / request.NumPerPage; result = result.Skip(request.NumPerPage * (request.CurrentPage - 1)).Take(request.NumPerPage); } return(new PaginatedResult <IEnumerable <Todo> >() { Data = result, TotalItems = totalItems, TotalPages = totalPages }); }
public async Task <ICollection <Project> > GetProjectsAsync(PaginatedRequest request, IUserContext userContext) { var offsetRecords = (request.Page - 1) * request.Results; var sortDirection = request.Direction == SortDirection.Ascending ? "ASC" : "DESC"; var query = $@"SELECT * FROM Projects WHERE (@UserId IS NULL OR UserId = @UserId) ORDER BY CASE WHEN @OrderBy IS NULL THEN ProjectId ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'Name' THEN Name ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'Description' THEN Description ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'Location' THEN Location ELSE NULL END {sortDirection}, CASE WHEN @OrderBy = 'DateCreatedUtc' THEN DateCreatedUtc ELSE NULL END {sortDirection} OFFSET {offsetRecords} ROWS FETCH NEXT {request.Results} ROWS ONLY;"; var result = await SqlQueryAsync <Project>(query, new { Results = request.Results, Page = request.Page, OrderBy = request.OrderBy, Direction = request.Direction, UserId = userContext?.UserId }); return(result.ToList()); }
public PaginatedInterestCard GetUserInterests(string currUserId, PaginatedRequest req) { PaginatedInterestCard ret = new PaginatedInterestCard(); userGroupFollowIds = _userLikesCacheService.GetUserFollowingGroupsIds(currUserId); if (userGroupFollowIds == null || userGroupFollowIds.Count() == 0) { userGroupFollowIds = _userLikesDataService.GetUserFollowingGroups(currUserId, 30); _userLikesCacheService.SetUserFollowingGroupsIds(currUserId, userGroupFollowIds, 20); } int total = userGroupFollowIds.Count(); if (total < 1) { return(ret); } int[] paginatedIds = userGroupFollowIds.Skip((req.PageIndex - 1) * req.PageSize).Take(req.PageSize).ToArray(); ret.Entities = _context.Set <Group>().AsNoTracking() .Select(f => new { Entity = f, f.ProfileImage }) .Where(p => paginatedIds.Contains(p.Entity.Id)) .Select(p => new InterestCard() { AlphaColor = p.Entity.ColorAlpha, UrlKey = p.Entity.UrlKey, Id = p.Entity.Id, Name = p.Entity.Name, IsCurrentUserFollowing = true, ProfileImage = p.Entity.ProfileImage.SmallPath }).ToPaginatedList(req.PageIndex, req.PageSize, total); return(ret); }
//Single Get for getting all data with queries/pagination public PaginatedItemsResponse <Job> GetAllJobsWithFilter(PaginatedRequest model) { List <Job> JobList = null; PaginatedItemsResponse <Job> response = null; DataProvider.ExecuteCmd(GetConnection, "dbo.Jobs_SelectAll" , inputParamMapper : delegate(SqlParameterCollection paramCollection) { paramCollection.AddWithValue("@CurrentPage", model.CurrentPage); paramCollection.AddWithValue("@ItemsPerPage", model.ItemsPerPage); paramCollection.AddWithValue("@Query", model.Query); paramCollection.AddWithValue("@QueryWebsiteId", model.QueryWebsiteId); paramCollection.AddWithValue("@QueryStatus", model.QueryStatus); paramCollection.AddWithValue("@QueryJobType", model.QueryJobType); paramCollection.AddWithValue("@QueryStartDate", model.QueryStartDate); paramCollection.AddWithValue("@QueryEndDate", model.QueryEndDate); }, map : delegate(IDataReader reader, short set) { if (set == 0) { Job SingleJob = new Job(); int startingIndex = 0; //startingOrdinal SingleJob.Id = reader.GetSafeInt32(startingIndex++); SingleJob.UserId = reader.GetSafeString(startingIndex++); SingleJob.JobStatus = reader.GetSafeEnum <JobStatus>(startingIndex++); SingleJob.JobType = reader.GetSafeEnum <JobsType>(startingIndex++); SingleJob.Price = reader.GetSafeDecimal(startingIndex++); SingleJob.Phone = reader.GetSafeString(startingIndex++); SingleJob.JobRequest = reader.GetSafeInt32(startingIndex++); SingleJob.SpecialInstructions = reader.GetSafeString(startingIndex++); SingleJob.Created = reader.GetSafeDateTime(startingIndex++); SingleJob.Modified = reader.GetSafeDateTime(startingIndex++); SingleJob.WebsiteId = reader.GetSafeInt32(startingIndex++); if (JobList == null) { JobList = new List <Job>(); } JobList.Add(SingleJob); } else if (set == 1) { response = new PaginatedItemsResponse <Job>(); response.TotalItems = reader.GetSafeInt32(0); } } ); response.Items = JobList; response.CurrentPage = model.CurrentPage; response.ItemsPerPage = model.ItemsPerPage; return(response); }
public IActionResult Hfinterests([FromQuery] PaginatedRequest model) { PaginatedInterestCard ret; Claim idClaim = User.FindFirst("sub"); ret = _feedDataService.GetUserInterests(idClaim?.Value, model); return(Ok(ret)); }
public Task <PaginatedResponse <Repository> > GetAllPublicAsync(PaginatedRequest paginatedRequest) { var parameters = CreateDefaultPaginationParameters(paginatedRequest); var restRequest = new RestComplexRequest(Method.GET, null, parameters); var task = MakeAsyncRequest <PaginatedResponse <Repository> >(string.Empty, restRequest); return(task); }
private static IQueryable <T> Sort <T>(this IQueryable <T> query, PaginatedRequest pagedRequest) { if (!string.IsNullOrWhiteSpace(pagedRequest.ColumnNameForSorting)) { query = query.OrderBy(pagedRequest.ColumnNameForSorting + " " + pagedRequest.SortDirection); } return(query); }
protected Dictionary <string, string> CreateDefaultPaginationParameters(PaginatedRequest request) { var dictionary = new Dictionary <string, string>(); dictionary.Add(request.Page.Name, request.Page.Value.ToString()); dictionary.Add(request.PageLength.Name, request.PageLength.Value.ToString()); return(dictionary); }
public async Task <Result <string, OkraError> > RetrieveAuthAsPdfAsync(PaginatedRequest request) { var url = "products/auths"; var response = await _okraApi.Post <RetrieveAuthAsPdfResponse, RetrieveAuthAsPdfRequest>(url, new RetrieveAuthAsPdfRequest { Limit = request.Limit, Page = request.Page }); return(response.ToResult()); }
public PaginatedItemsResponse <UserCredits> GetTransactionsPaginated(PaginatedRequest model) { List <UserCredits> TransactionsList = null; PaginatedItemsResponse <UserCredits> response = null; DataProvider.ExecuteCmd(GetConnection, "dbo.UserCredits_SelectAll" , inputParamMapper : delegate(SqlParameterCollection paramCollection) { paramCollection.AddWithValue("@CurrentPage", model.CurrentPage); paramCollection.AddWithValue("@ItemsPerPage", model.ItemsPerPage); paramCollection.AddWithValue("@Query", model.Query); }, map : delegate(IDataReader reader, short set) { if (set == 0) { UserCredits data = new UserCredits(); int startingIndex = 0; //startingOrdinal data.Id = reader.GetSafeInt32(startingIndex++); data.UserId = reader.GetSafeString(startingIndex++); data.Amount = reader.GetSafeDecimal(startingIndex++); data.TransactionId = reader.GetSafeInt32(startingIndex++); data.JobId = reader.GetSafeInt32(startingIndex++); data.DateAdded = reader.GetSafeDateTime(startingIndex++); UserMini User = new UserMini(); User.FirstName = reader.GetSafeString(startingIndex++); User.LastName = reader.GetSafeString(startingIndex++); User.Email = reader.GetSafeString(startingIndex++); User.Phone = reader.GetSafeString(startingIndex++); User.Url = reader.GetSafeString(startingIndex++); data.User = User; if (TransactionsList == null) { TransactionsList = new List <UserCredits>(); } TransactionsList.Add(data); } else if (set == 1) { response = new PaginatedItemsResponse <UserCredits>(); response.TotalItems = reader.GetSafeInt32(0); } } ); response.Items = TransactionsList; response.CurrentPage = model.CurrentPage; response.ItemsPerPage = model.ItemsPerPage; return(response); }
public Task <PaginatedResponse <Repository> > GetForksAsync(string owner, string reposlug, PaginatedRequest paginatedRequest) { var segments = CreateDefaultSegmentsDictionary(owner, reposlug); var parameters = CreateDefaultPaginationParameters(paginatedRequest); var restRequest = new RestComplexRequest(Method.GET, segments, parameters); var task = MakeAsyncRequest <PaginatedResponse <Repository> >(FORKS_REPOSITORY_RESOURCE, restRequest); return(task); }
public Task <PaginatedResponse <Activity> > GetAllActivityAsync(string owner, string reposlug, PaginatedRequest paginatedRequest) { var segments = CreateDefaultSegmentsDictionary(owner, reposlug); var parameters = CreateDefaultPaginationParameters(paginatedRequest); var request = new RestComplexRequest(Method.GET, segments, parameters); var task = MakeAsyncRequest <PaginatedResponse <Activity> >(ACTIVITY_PULL_REQUEST_RESOURCE, request); return(task); }
public HttpResponseMessage GetAllJobsWithFilter([FromUri] PaginatedRequest model) { if (!ModelState.IsValid) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } PaginatedItemsResponse <Job> response = _JobsService.GetAllJobsWithFilter(model); return(Request.CreateResponse(HttpStatusCode.OK, response)); }
public virtual async Task <WhereResult <RoleData> > Where(PaginatedRequest req, Func <Role, bool> predicate) { var count = await _context.RoleSet.CountAsync(u => predicate(u)); var list = await _context.RoleSet.Where(predicate) .Skip(req.CurrentPage * req.ItemPerPage) .Take(req.ItemPerPage) .Select(i => new RoleData(i)).AsQueryable().ToListAsync(); return(new WhereResult <RoleData>(new PaginatedResult <RoleData>(req, totalItems: count, items: list))); }
//get all competency users. this is used to populate the index page. //some dir-paginate calls in here that do not work yet. public PaginateItemsResponse <CompetencyUser> GetCompetencyUsers() { PaginatedRequest model = new PaginatedRequest(); List <CompetencyUser> userList = null; PaginateItemsResponse <CompetencyUser> response = null; DataProvider.ExecuteCmd(GetConnection, "dbo.Competency_Users_SelectAll" , inputParamMapper : delegate(SqlParameterCollection paramCollection) { paramCollection.AddWithValue("@CurrentPage", model.CurrentPage); paramCollection.AddWithValue("@ItemsPerPage", model.ItemsPerPage); paramCollection.AddWithValue("@Query", model.Query); }, map : delegate(IDataReader reader, short set) { if (set == 0) { CompetencyUser CompetencyUser = new CompetencyUser(); int startingIndex = 0; CompetencyUser.Id = reader.GetSafeString(startingIndex++); CompetencyUser.FirstName = reader.GetSafeString(startingIndex++); CompetencyUser.LastName = reader.GetSafeString(startingIndex++); CompetencyUser.CompetencyId = reader.GetSafeInt32(startingIndex++); CompetencyUser.CompetencyName = reader.GetSafeString(startingIndex++); CompetencyUser.Email = reader.GetSafeString(startingIndex++); CompetencyUser.AuthorizedBy = reader.GetSafeString(startingIndex++); CompetencyUser.CreatedDate = reader.GetDateTime(startingIndex++); CompetencyUser.Status = reader.GetSafeString(startingIndex++); CompetencyUser.ActivityType = reader.GetSafeString(startingIndex++); CompetencyUser.Notes = reader.GetSafeString(startingIndex++); CompetencyUser.Attachments = reader.GetSafeString(startingIndex++); CompetencyUser.competencyUserId = reader.GetSafeInt32(startingIndex++); if (userList == null) { userList = new List <CompetencyUser>(); } userList.Add(CompetencyUser); } else if (set == 1) { response = new PaginateItemsResponse <CompetencyUser>(); response.TotalItems = reader.GetSafeInt32(0); } } ); response.Items = userList; response.CurrentPage = model.CurrentPage; response.ItemsPerPage = model.ItemsPerPage; return(response); }
public Task <PaginatedResponse <User> > GetFollowingAsync(string teamName, PaginatedRequest request) { var segments = new Dictionary <string, string>() { { TEAM_NAME_SEGMENT, teamName } }; var restRequest = new RestComplexRequest(Method.GET, segments, null); var task = MakeAsyncRequest <PaginatedResponse <User> >(TEAM_FOLLOWING_RESOURCE, restRequest); return(task); }
public async Task <PaginatedResult <ApplicationUserModel> > GetUsersAsync(PaginatedRequest paginatedRequest) { var users = await _users.CreatePaginatedResultAsync <ApplicationUserModel>(paginatedRequest, _mapper); foreach (var appUserDTO in users.Items) { appUserDTO.RoleString = _personalInfoRepository.GetRoleName(appUserDTO.userRoleId); } return(users); }
public Task <PaginatedResponse <Comment> > GetCommentsAsync(string owner, string repoSlug, string revision, PaginatedRequest paginatedRequest) { var segments = CreateDefaultSegmentsDictionary(owner, repoSlug); segments.Add(REVISION_SEGMENT, revision); var parameters = CreateDefaultPaginationParameters(paginatedRequest); var restRequest = new RestComplexRequest(Method.GET, segments, parameters, null); var task = MakeAsyncRequest <PaginatedResponse <Comment> >(SPECIFIED_COMMIT_COMMENTS_RESOURCE, restRequest); return(task); }
public async Task <WhereResult <UserData> > Where(PaginatedRequest req, Func <User, bool> predicate) { try { return(await _query.Where(req, predicate)); } catch (Exception ex) { //TODO Trace ex return(new WhereResult <UserData>(ex)); } }
public async Task <IActionResult> Get(PaginatedRequest request, CancellationToken cancellationToken) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var result = await _showsService.GetAllPaginatedAsync(request.Page, request.PageSize, cancellationToken); return(Ok(result)); }
public Task <PaginatedResponse <Comment> > GetCommentsAsync(string owner, string reposlug, long pullRequestId, PaginatedRequest paginatedRequest) { var segments = CreateDefaultSegmentsDictionary(owner, reposlug); segments.Add(PULL_REQUEST_ID_SEGMENT, pullRequestId.ToString()); var parameters = CreateDefaultPaginationParameters(paginatedRequest); var request = new RestComplexRequest(Method.GET, segments, parameters); var task = MakeAsyncRequest <PaginatedResponse <Comment> >(COMMENTS_PULL_REQUEST_RESOURCE, request); return(task); }
public Task <PaginatedResponse <User> > GetFollowingAsync(string user, PaginatedRequest request) { var segments = new Dictionary <string, string>() { { USERNAME_SEGMENT, user } }; var parameters = CreateDefaultPaginationParameters(request); var restRequest = new RestComplexRequest(Method.GET, segments, parameters); var task = MakeAsyncRequest <PaginatedResponse <User> >(FOLLOWING_RESOURCE, restRequest); return(task); }
public Task <PaginatedResponse <Repository> > GetAllAsync(string owner, PaginatedRequest paginatedRequest) { var segments = new Dictionary <string, string>() { { OWNER_SEGMENT, owner } }; var parameters = CreateDefaultPaginationParameters(paginatedRequest); var restRequest = new RestComplexRequest(Method.GET, segments, parameters); var task = MakeAsyncRequest <PaginatedResponse <Repository> >(DEFAULT_OWNER_RESOURCE, restRequest); return(task); }
public HttpResponseMessage GetCsv([FromUri] PaginatedRequest model) { string exportResponse = _AdminReportService.ExportCsv(model); HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK); result.Content = new StringContent(exportResponse, Encoding.UTF8, "text/csv"); result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment"); //attachment will force download result.Content.Headers.ContentDisposition.FileName = "Reports.csv"; return(result); }
public async Task<PaginatedResponse<IEnumerable<WebFriendInformationResponse>>> GetWebFriends(PaginatedRequest<string> request, SystemSession session) { var serviceRequest = new WebOnlyFriend { UserId = session.UserId, TargetUser = request.Data, PageIndex = request.PageIndex, PageSize = request.PageSize }; var data = await Task.Factory.StartNew(() => Client.UserService.getWebOnlyFriends(serviceRequest, session.GetSession())).ConfigureAwait(false); var result = new PaginatedResponse<IEnumerable<WebFriendInformationResponse>> { Page = data.WebOnlyFriends.Select(x => new WebFriendInformationResponse { UserId = x.UserId, UserName = x.Username, FirstName = x.FirstName, LastName = x.LastName, StatusTypeId = (SystemUserAvailabilityCode)x.Status, MobileNumber = x.PrimaryContactNum, Title = x.Title, UserTypeId = (SystemUserType)x.UserTypeId, Image = x.Picture, FriendshipStatus = (SystemFriendshipStatus)x.IsConnected, MutualFriend = x.MutualFriends, Address = x.Address, Email = x.Email, CanMessage = x.CanMessage, AllowMessageForwarding = x.AllowMsgForwarding, CanReceiveConnectionRequest = x.CanReceiveConnectionReq, AllowAddingInChatGroup = x.AllowAddingChatGroup }), HasNextPage = data.HasNextPage, }; return result; }
public Task<PaginatedResponse<IEnumerable<WebFriendInformationResponse>>> GetWebFriends(PaginatedRequest<string> request, SystemSession session) { return _jUnitOfWork.Friend.GetWebFriends(request, session); }
public Task<PaginatedResponseExtended<IEnumerable<UserInformationBaseExtendedResponse>, int>> GetMutualFriends(PaginatedRequest<string> request, SystemSession session) { return _jUnitOfWork.Friend.GetMutualFriends(request, session); }
public async Task<HttpResponseMessage> GetSkill(PaginatedRequest<string> request) { if (!(request.Data.IsMatch(x => request.Data, RegexPattern.UserName, ActionContext, ModelState) && Validation.StringLength(request.Data, x => request.Data, 6, 30, ActionContext, ModelState)) && !request.Data.IsMatch(x => request.Data, RegexPattern.Numeric, ActionContext, ModelState)) return ActionContext.Response; var response = await _profilePersonalService.GetUserSkills(request, Request.GetSession()).ConfigureAwait(false); return Request.SystemResponse(SystemDbStatus.Selected, response); }
public async Task<PaginatedResponse<IEnumerable<UserSkillResponse>>> GetUserSkills(PaginatedRequest<string> request, SystemSession session) { var serviceRequest = new Skill { UserIdOrName = session.UserName, ProfileUser = request.Data, Offset = request.PageIndex, PageSize = request.PageSize }; var response = await Task.Factory.StartNew(() => Client.UserService.getSkillSummary(serviceRequest, session.GetSession())).ConfigureAwait(false); var data = response.Skills.Select(x => new UserSkillResponse { Name = x.SkillName, SkillTypeId = x.SkillTypeId, ThumbsCount = x.ThumbsCount, YourThumb = x.YourThumb, UsersString = x.Users }).ToList(); var allUsers = response.Skills.Where(x => x.Users != null).SelectMany(x => x.Users.Split(',')).Distinct().ToList(); if (allUsers.Any()) { var users = await Task.Factory.StartNew(() => Client.UserService.getUsersInfo(string.Join(",", allUsers), session.GetSession())).ConfigureAwait(false); var usersInformation = users.Select(x => new UserInformationBaseExtendedResponse { UserId = x.UserId, UserName = x.UserName, UserTypeId = (SystemUserType)x.UserTypeId, Image = x.Picture, FirstName = x.FirstName, LastName = x.LastName, Title = x.Title }).ToList(); foreach (var userSkillResponse in data.Where(userSkillResponse => !string.IsNullOrEmpty(userSkillResponse.UsersString))) { var skillResponse = userSkillResponse; userSkillResponse.Users = usersInformation.Where(x => skillResponse.UsersString.Split(',').ToList().ConvertAll(Convert.ToInt32).Contains(x.UserId)); } } var result = new PaginatedResponse<IEnumerable<UserSkillResponse>> { Page = data, HasNextPage = response.HasNextPage }; return result; }
public Task<PaginatedResponse<IEnumerable<UserSkillResponse>>> GetUserSkills(PaginatedRequest<string> request, SystemSession session) { // return _unitOfWork.Profile.GetUserSkills(request); return _jUnitOfWork.ProfilePersonal.GetUserSkills(request, session); }
public Task<PaginatedResponse<IEnumerable<ThumbsForSkillDetailResponse>>> GetThumbsForSkillDetail(PaginatedRequest<ThumbsForSkillDetailRequest> request, SystemSession session) { return _jUnitOfWork.ProfilePersonal.GetThumbsForSkillDetail(request.Data, request.PageIndex, request.PageSize, session); }
public Task<PaginatedResponseExtended<IEnumerable<ViewerDetailResponse>, int>> GetProfileViewDetail(PaginatedRequest<GeneralKvPair<SystemProfileViewType, int>> request, SystemSession getSession) { // return _unitOfWork.Profile.GetProfileViewDetail(request); return _jUnitOfWork.Profile.GetProfileViewDetail(request, getSession); }
public Task<PaginatedResponseExtended<IEnumerable<ViewSummaryResponse>, int>> GetProfileViewSummary(PaginatedRequest<int> request, SystemSession getSession) { //return _unitOfWork.Profile.GetProfileViewSummary(request); return _jUnitOfWork.Profile.GetProfileViewSummary(request, getSession); }
public Task<PaginatedResponse<IEnumerable<FriendsInCategoryResponse>>> GetFriendsInCategory(PaginatedRequest<FriendsInCategoryRequest> request, SystemSession session) { return _jUnitOfWork.Category.GetFriendsInCategory(request, session); }