public static async Task <PaginatedResponse <T> > GetHelper <T>(this IHttpService httpService, string url,
PaginationDTO paginationDTO, bool includeToken = true)
{
string newURL = "";
if (url.Contains("?"))
{
newURL = $"{url}&page={paginationDTO.Page}&recordsPerPage={paginationDTO.RecordsPerPage}";
}
else
{
newURL = $"{url}?page={paginationDTO.Page}&recordsPerPage={paginationDTO.RecordsPerPage}";
}
var httpResponse = await httpService.Get <T>(newURL, includeToken);
var totalAmountPages = int.Parse(httpResponse.HttpResponseMessage.Headers.GetValues("totalAmountPages").FirstOrDefault());
var paginatedResponse = new PaginatedResponse <T>
{
Response = httpResponse.Response,
TotalAmountPages = totalAmountPages
};
return(paginatedResponse);
}
public IActionResult Get(int pageIndex, int pageSize)
{
// most recents orders
// Include -> entety framework
var data = _context.Orders.Include(o => o.Client).OrderByDescending(c => c.Placed);
// after getting the "raw" data - specified the data in pages and sizes to display this orders
var page = new PaginatedResponse <Orders>(data, pageIndex, pageSize);
var totalCount = data.Count();
// https://docs.microsoft.com/en-us/dotnet/api/system.math.ceiling?view=netcore-3.1
var totalPages = Math.Ceiling((double)totalCount / pageSize);
// response
var response = new
{
// PaginatedResponse
Page = page,
TotalPages = totalPages
};
// http 200 status response with the response
// return Ok response
return(Ok(response));
}
public async Task <PaginatedResponse <IEnumerable <BasicSearchResponse> > > BasicSearch(int userId, string deviceId, string searchTerm, byte?userTypeId, byte?isConnected, int pageIndex, int pageSize)
{
await Task.Delay(1).ConfigureAwait(false);
var hasNextPage = new ObjectParameter("HASNEXTPAGE", typeof(bool));
var pg = Context.PROC_BASIC_SEARCH(userId, deviceId, searchTerm, userTypeId, isConnected, pageIndex, (pageSize + 1), hasNextPage).ToList();
var page = new PaginatedResponse <IEnumerable <BasicSearchResponse> >
{
Page = pg
.Select(x => new BasicSearchResponse
{
UserId = x.USERID,
UserTypeId = (SystemUserType)x.USERTYPEID,
FirstName = x.FIRSTNAME,
LastName = x.LASTNAME,
Title = x.TITLE,
CountryCode = x.COUNTRYCODE,
FriendshipStatus = (SystemFriendshipStatus)x.ISCONNECTED,
MutualFriends = x.MUTUALFRIENDS,
StatusTypeId = (SystemUserAvailabilityCode)x.STATUS,
Image = x.PICTURE,
UserName = x.USERNAME,
AllowAddingInChatGroup = x.ALLOWADDINGINCHATGROUP,
AllowMessageForwarding = x.ALLOWMESSAGEFORWARDING,
CanMessage = x.CANMESSAGE,
CanReceiveConnectionRequest = x.CANRECEIVECONNECTIONREQUEST,
IsFromPhoneBook = x.ISFROMPHONEBOOK,
MobileNumber = x.PRIMARYCONTACTNUMBER
})
};
page.HasNextPage = Convert.ToBoolean(hasNextPage.Value);
page.Page = page.Page.Take(pageSize);
return(page);
}
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 static async Task <PaginatedResponse <T> > GetHelper <T>(this IHttpService httpService, string url, PaginationDTO paginationDTO)
{
string newURL;
if (url.Contains("?"))
{
// Append to existing query string.
newURL = $"{url}&page={paginationDTO.Page}&numPerPage={paginationDTO.NumPerPage}";
}
else
{
// Add query string.
newURL = $"{url}?page={paginationDTO.Page}&numPerPage={paginationDTO.NumPerPage}";
}
var httpResponse = await httpService.Get <T>(newURL);
var numPages = int.Parse(httpResponse.HttpResponseMessage.Headers.GetValues("numPages").FirstOrDefault());
var paginatedResponse = new PaginatedResponse <T>
{
Response = httpResponse.Response,
NumPages = numPages
};
return(paginatedResponse);
}
public void ListServicesResponse()
{
var services = new PaginatedResponse <Service>(_response).Data;
var service = services.First();
var serviceSetting = services.Last().Settings.First();
Assert.Multiple(() =>
{
Assert.AreEqual(1, service.Id);
Assert.AreEqual("Service 1", service.Name);
Assert.AreEqual("service1", service.Sid);
Assert.AreEqual("First service example.", service.Description);
Assert.IsNull(service.SetupDescription);
Assert.IsFalse(service.RequiresSetup);
Assert.IsNull(service.DefaultSubdomain);
Assert.AreEqual(CreatedAt, service.CreatedAt);
Assert.AreEqual(UpdatedAt, service.UpdatedAt);
Assert.IsEmpty(service.Settings);
Assert.AreEqual(1, services.Last().Settings.Count);
Assert.AreEqual("username", serviceSetting.Name);
Assert.AreEqual("Service 2 Account Username", serviceSetting.Label);
Assert.AreEqual(".service2.com", serviceSetting.Append);
Assert.AreEqual("Your Service2 username is used to connect services to your account.", serviceSetting.Description);
Assert.AreEqual("username", serviceSetting.Example);
Assert.IsFalse(serviceSetting.Password);
});
}
private void EmptyData_ReturnsEmpty()
{
data.Clear();
PaginatedResponse <int> paginatedData = new PaginatedResponse <int>(data, paginationParameters);
Assert.Empty(paginatedData.Data);
}
private void DefaultDataThirdPage_HasFiveItems()
{
PaginationParameters paginationParameters = new PaginationParameters(10, 3);
PaginatedResponse <int> paginatedResponse = new PaginatedResponse <int>(data, paginationParameters);
Assert.Equal(5, paginatedResponse.Data.Count());
}
private void PageSizeZero_SetToTen()
{
paginationParameters = new PaginationParameters(0, 1);
PaginatedResponse <int> paginatedResponse = new PaginatedResponse <int>(data, paginationParameters);
Assert.Equal(10, paginationParameters.PageSize);
}
public static async Task <PaginatedResponse <T> > GetHelper <T>(this IHttpService httpService, string url,
PaginationDTO paginationDTO)
{
Console.WriteLine($" GetHelper 0{url}");
string newURL = "";
if (url.Contains("?"))
{
newURL = $"{url}&page={paginationDTO.Page}&recordsPerPage={paginationDTO.RecordsPerPage}";
}
else
{
newURL = $"{url}?page={paginationDTO.Page}&recordsPerPage={paginationDTO.RecordsPerPage}";
}
Console.WriteLine($"=== 1 {newURL}");
var httpResponse = await httpService.Get <T>(newURL);
Console.WriteLine("=== 2");
var totalAmountPages = int.Parse(httpResponse.HttpResponseMessage.Headers.GetValues("totalAmountPages").FirstOrDefault());
var paginatedResponse = new PaginatedResponse <T>
{
Response = httpResponse.Response,
TotalAmountPages = totalAmountPages
};
Console.WriteLine("=== 3");
return(paginatedResponse);
}
private async void SetUpEvents()
{
var eventsResponse = await _apiManager.GetEvents(Config.Token);
if (eventsResponse.IsSuccessStatusCode)
{
var json = await eventsResponse.Content.ReadAsStringAsync();
PaginatedResponse <Event> events = await Task.Run(() => JsonConvert.DeserializeObject <PaginatedResponse <Event> >(json));
foreach (Event e in events.Results)
{
string formatter = "yyyy-MM-dd HH:mm:ss";
DateTime from = DateTime.ParseExact($"{e.Date} {e.StartTime}", formatter,
CultureInfo.InvariantCulture);
DateTime to = DateTime.ParseExact($"{e.Date} {e.EndTime}", formatter,
CultureInfo.InvariantCulture);
CalendarInlineEvent meeting = new CalendarInlineEvent {
Subject = e.Title, StartTime = from, EndTime = to
};
Appointments.Add(meeting);
Events.Add(e);
}
}
}
public async Task Should_Register_User()
{
IMatrixClient client = new MatrixClient(
Fixture.Settings.Server
);
PaginatedResponse <PublicRoomsChunk> response = await client.MakeRequestAsync(
new ListPublicRoomsRequest { Limit = 8 }
);
Assert.Null(response.PrevBatch);
Assert.NotEmpty(response.NextBatch);
if (response.TotalRoomCountEstimate != null)
{
Assert.True(
0 < response.TotalRoomCountEstimate,
"Rooms count estimate should be greater than 0."
);
}
Assert.NotNull(response.Chunk);
Assert.Equal(8, response.Chunk.Count());
foreach (PublicRoomsChunk roomChunk in response.Chunk)
{
MatrixAssert.ValidRoomChunk(roomChunk);
}
}
/// <summary>Asynchronously retrieve the JSON encoded content and converts it to a 'PaginatedResponse' object.</summary>
/// <typeparam name="T">The response model to deserialize into.</typeparam>
/// <param name="httpContent">The content.</param>
/// <param name="propertyName">The name of the JSON property (or null if not applicable) where the desired data is stored.</param>
/// <param name="jsonConverter">Converter that will be used during deserialization.</param>
/// <returns>Returns the response body, or <c>null</c> if the response has no body.</returns>
/// <exception cref="ApiException">An error occurred processing the response.</exception>
private static async Task <PaginatedResponse <T> > AsPaginatedResponse <T>(this HttpContent httpContent,
string propertyName, JsonConverter jsonConverter = null)
{
var responseContent = await httpContent.ReadAsStringAsync(null).ConfigureAwait(false);
var jObject = JObject.Parse(responseContent);
var serializer = new JsonSerializer();
if (jsonConverter != null)
{
serializer.Converters.Add(jsonConverter);
}
var result = new PaginatedResponse <T>
{
PageCount = jObject.Property("page_count").Value.ToObject <int>(),
PageNumber = jObject.Property("page_number").Value.ToObject <int>(),
PageSize = jObject.Property("page_size").Value.ToObject <int>(),
Records = jObject.Property(propertyName).Value.ToObject <T[]>(serializer),
TotalRecords = jObject.Property("total_records").Value.ToObject <int>()
};
return(result);
}
public static async Task <PaginatedResponse <T> > GetHelper <T>(this IHttpService httpService, string url, PaginationDTO paginationDTO)
{
string newUrl = string.Empty;
if (url.Contains("?"))
{
newUrl = $"{url}&page={paginationDTO.Page}&recordsPerPage={paginationDTO.RecordsPerPage}";
}
else
{
newUrl = $"{url}?page={paginationDTO.Page}&recordsPerPage={paginationDTO.RecordsPerPage}";
}
var httpResponse = await httpService.Get <T>(newUrl);
var totalAmountOfPages = int.Parse(httpResponse.HttpResponseMessage.Headers.GetValues("totalAmountPages").FirstOrDefault());
var paginatedResponse = new PaginatedResponse <T>()
{
Response = httpResponse.Response,
TotalAmountPages = totalAmountOfPages
};
if (!httpResponse.Success)
{
throw new ApplicationException(await httpResponse.GetBody());
}
return(paginatedResponse);
}
public async Task <PaginatedResponse <IEnumerable <ResignationViewResponse> > > GetResignationRequest(int pageIndex, int pageSize, SystemSession session)
{
var serviceRequest = new Employees
{
UserId = session.UserId,
Offset = pageIndex,
PageSize = pageSize
};
var response = await Task.Factory.StartNew(() => Client.UserService.getResignationRequest(serviceRequest, session.GetSession())).ConfigureAwait(false);
var result = new PaginatedResponse <IEnumerable <ResignationViewResponse> >
{
HasNextPage = response.HasNextPage,
Page = response.Employees.Select(
x => new ResignationViewResponse
{
PersonEmploymentId = x.PersonEmploymentId,
User = new UserResponse
{
UserId = x.UserId,
UserName = x.Username,
Name = x.Name,
Picture = x.Picture
},
Position = x.Position,
EndDate = x.EndDate != null ? Convert.ToDateTime(x.EndDate) : (DateTime?)null
})
};
return(result);
}
public async Task <PaginatedResponse <IEnumerable <EmployeeDepartmentResponse> > > GetCompanyDepartmentEmployeeList(int userId, int?employeeId, int?departmentId, int pageIndex, int pageSize)
{
var page = new PaginatedResponse <IEnumerable <EmployeeDepartmentResponse> >
{
Page = await Task.Factory.StartNew(() => Context.CompanyDepartmentEmployees.Where(x => (x.UserID == userId && ((!employeeId.HasValue || x.EmployeeID == employeeId) &&
(!departmentId.HasValue || x.DepartmentID == departmentId))))
.Select(x => new EmployeeDepartmentResponse
{
DepartmentId = x.DepartmentID,
Employee =
new GeneralKvPair <int, string>
{
Id = x.EmployeeID,
Value = x.UserInfoPerson.FirstName + " " + x.UserInfoPerson.LastName
},
Added = x.Added
}).OrderBy(x => x.DepartmentId)
.ThenBy(x => x.Employee)
.Skip(pageIndex *pageSize)
.Take(pageSize + 1)
.ToList()).ConfigureAwait(false)
};
page.HasNextPage = page.Page.Count() > pageSize;
page.Page = page.Page.Take(pageSize);
return(page);
}
//New
public static async Task <PaginatedResponse <T> > GetHelper2 <T>(this IHttpService httpService, string url,
PaginationSearchDTO paginationSearchDTO)
{
string newURL = "";
if (url.Contains("?"))
{
newURL = $"{url}&page={paginationSearchDTO.Page}&recordsPerPage={paginationSearchDTO.RecordsPerPage}&searchText={paginationSearchDTO.SearchText}";
}
else
{
newURL = $"{url}?page={paginationSearchDTO.Page}&recordsPerPage={paginationSearchDTO.RecordsPerPage}&searchText={paginationSearchDTO.SearchText}";
}
var httpResponse = await httpService.GetPagination <T>(newURL);
var totalAmountPages = int.Parse(httpResponse.HttpResponseMessage.Headers.GetValues("totalAmountPages").FirstOrDefault());
var totalAmount = long.Parse(httpResponse.HttpResponseMessage.Headers.GetValues("totalAmount").FirstOrDefault());
var paginatedResponse = new PaginatedResponse <T>
{
Response = httpResponse.Response,
TotalAmountPages = totalAmountPages,
TotalAmount = totalAmount
};
return(paginatedResponse);
}
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 async Task <ActionResult <PaginatedResponse <GetFlickEntriesResponseItem> > > Action(
int profileId,
CancellationToken cancellationToken = default)
{
var profile = await _database.Profiles
.Include(p => p.FlickEntries)
.ThenInclude(f => f.Flick)
.FirstOrDefaultAsync(p => p.Id == profileId, cancellationToken);
if (profile is null)
{
return(Error(
HttpStatusCode.NotFound,
$"Profile '{profileId}' not found"
));
}
if (!profile.IsPublic && User.TryGetProfileId() != profileId)
{
return(Error(
HttpStatusCode.Forbidden,
$"Profile '{profileId}' is not public"
));
}
// TODO: pagination
return(Success(
HttpStatusCode.OK,
PaginatedResponse.Create(_mapper.Map <GetFlickEntriesResponseItem[]>(profile.FlickEntries), 1, 1)
));
}
public ActionResult <PaginatedResponseModel <Message> > GetMessages([FromQuery] PaginationParams param, string by)
{
var userID = User.FindFirst(x => x.Type == "UserID").Value;
PaginatedResponse <Message> messages;
switch (by)
{
case "by":
{
messages = new PaginatedResponse <Message>(_messageService.GetAllSentByUser(userID).OrderByDescending(x => x.Sent), param.PageSize, param.PageIndex);
} break;
case "to":
{
messages = new PaginatedResponse <Message>(_messageService.GetAllSentToUser(userID).OrderByDescending(x => x.Sent), param.PageSize, param.PageIndex);
}
break;
default:
messages = new PaginatedResponse <Message>(_messageService.GetAllSentByUser(userID).OrderByDescending(x => x.Sent), param.PageSize, param.PageIndex);
break;
}
var response = new PaginatedResponseModel <Message>
{
Items = messages.GetResult(),
ResponseInfo = messages.GetResponseInfo()
};
return(response);
}
public async Task <PaginatedResponse <InventoryApiModel> > Handle(GetAllInventoriesQuery request, CancellationToken cancellationToken)
// public async Task<IEnumerable<InventoryApiModel>> Handle(GetAllInventoriesQuery request, CancellationToken cancellationToken)
{
try
{
var inventories = await _repo.GetAllInventories(request, cancellationToken)
.ConfigureAwait(false);
var prev = _uriGen.AddQueryStringParams("pageNumber", (request.PageNumber - 1).ToString() !);
prev.AddQueryStringParams("pageSize", request.PageSize.ToString() !);
var nextL = _uriGen.AddQueryStringParams("pageNumber", (request.PageNumber + 1).ToString() !);
nextL.AddQueryStringParams("pageSize", request.PageSize.ToString() !);
var pagedList = PagedList <InventoryApiModel> .CreatePagedList(inventories.AsQueryable(),
request.PageNumber, request.PageSize);
var prevLink = pagedList.HasPrevious ? prev.GenerateUri() : null;
var nextLink = pagedList.HasNext ? nextL.GenerateUri() : null;
var result = new PaginatedResponse <InventoryApiModel>(pagedList, pagedList.TotalCount,
pagedList.PageSize, pagedList.CurrentPage, prevLink?.AbsoluteUri, nextLink?.AbsoluteUri, ResponseStatus.Success);
return(result);
}
catch (Exception e)
{
return(new PaginatedResponse <InventoryApiModel>(new PagedList <InventoryApiModel>(), 0, 10, 1, "", "", ResponseStatus.Error,
new { ErrorMessage = e.Message }));
// return new List<InventoryApiModel>();
}
}
public async Task <PaginatedResponse <IEnumerable <UserSkillResponse> > > GetUserSkills(PaginatedRequest <string> request)
{
var hasNextPage = new ObjectParameter("HASNEXTPAGE", typeof(bool));
var response = await Task.Factory.StartNew(() => Context.PROC_THUMBS_FOR_SKILL_SUMMARY(request.UserId.ToString(), request.Data, request.PageIndex, request.PageSize, hasNextPage).ToList()).ConfigureAwait(false);
var data = response.Select(x => new UserSkillResponse {
Name = x.SKILLNAME, SkillTypeId = x.SKILLTYPEID, ThumbsCount = x.THUMBSCOUNT, YourThumb = x.YOURTHUMB, UsersString = x.USERS
}).ToList();
var allUsers = response.Where(x => x.USERS != null).SelectMany(x => x.USERS.Split(',')).Distinct().ToList();
if (allUsers.Any())
{
var users = await Task.Factory.StartNew(() => Context.FNGETUSERSINFO(string.Join(",", allUsers)).ToList()).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 = Convert.ToBoolean(hasNextPage.Value)
};
return(result);
}
public async Task <PaginatedResponse <SaleApiModel> > Handle(GetAllSalesQuery request, CancellationToken cancellationToken)
{
try
{
var sales = await _repo.GetAllSales(request, cancellationToken).ConfigureAwait(false);
var prev = _uriGen.AddQueryStringParams("pageNumber", (request.PageNumber - 1).ToString() !);
prev.AddQueryStringParams("pageSize", request.PageSize.ToString() !);
var nextL = _uriGen.AddQueryStringParams("pageNumber", (request.PageNumber + 1).ToString() !);
nextL.AddQueryStringParams("pageSize", request.PageSize.ToString() !);
var prevLink = sales.HasPrevious
? prev.GenerateUri() : null;
var nextLink = sales.HasNext
? nextL.GenerateUri() : null;
var result = new PaginatedResponse <SaleApiModel>(sales,
sales.TotalCount, sales.PageSize, sales.CurrentPage,
prevLink?.PathAndQuery, nextLink?.PathAndQuery, ResponseStatus.Success);
return(result);
}
catch (Exception e)
{
return(new PaginatedResponse <SaleApiModel>(new PagedList <SaleApiModel>(), 0, 10, 1, "", "", ResponseStatus.Error, new { ErrorMessage = e.Message }));
}
}
public async Task <PaginatedResponse <IEnumerable <CompanyReviewResponse> > > GetCompanyReviews(SingleData <int> request, int pageIndex, int pageSize, SystemSession session)
{
var serviceRequest = new CompanyReview
{
CompanyId = request.Data,
OffSet = pageIndex,
PageSize = pageSize
};
var response = await Task.Factory.StartNew(() => Client.UserService.getCompanyReviews(serviceRequest, session.GetSession())).ConfigureAwait(false);
var result = new PaginatedResponse <IEnumerable <CompanyReviewResponse> >
{
HasNextPage = response.HasNextPage,
Page = response.CompanyReviews.Select(
x => new CompanyReviewResponse
{
CompanyReviewGuid = x.CompanyReviewGUID != null ? Guid.Parse(x.CompanyReviewGUID) : Guid.Empty,
User = new UserResponse
{
UserId = x.UserId,
UserName = x.Username,
Name = x.Name,
Picture = x.PictureUrl
},
Star = x.Star,
Title = x.Title,
Comment = x.Comment,
DateCommented = x.DateCommented != null ? Convert.ToDateTime(x.DateCommented) : (DateTime?)null,
IsApproved = x.IsApproved
})
};
return(result);
}
public async Task <PaginatedResponse <IEnumerable <ThumbsForSkillDetailResponse> > > GetThumbsForSkillDetail(ThumbsForSkillDetailRequest request, int pageIndex, int pageSize, SystemSession session)
{
var serviceRequest = new Kauwa.Skill
{
UserIdOrName = request.TargetUser,
SkillTypeId = request.SkillTypeId,
Offset = pageIndex,
PageSize = pageSize
};
var response = await Task.Factory.StartNew(() => Client.UserService.thumbsForSkillDetails(serviceRequest, session.GetSession())).ConfigureAwait(false);
var result = new PaginatedResponse <IEnumerable <ThumbsForSkillDetailResponse> >
{
HasNextPage = response.HasNextPage,
Page = response.Skills.Select(
x => new ThumbsForSkillDetailResponse
{
User = new UserResponse
{
UserId = x.UserId,
UserName = x.Username,
Name = x.Name,
Picture = x.Picture
},
UporDown = x.ThumbsUpOrDown
})
};
return(result);
}
public void ContactsResponse()
{
var contacts = new PaginatedResponse <Contact>(_response).Data;
var contact = contacts.First();
Assert.Multiple(() =>
{
Assert.AreEqual(1, contact.Id);
Assert.AreEqual(1010, contact.AccountId);
Assert.AreEqual("Default", contact.Label);
Assert.AreEqual("First", contact.FirstName);
Assert.AreEqual("User", contact.LastName);
Assert.AreEqual("CEO", contact.JobTitle);
Assert.AreEqual("Awesome Company", contact.OrganizationName);
Assert.AreEqual("*****@*****.**", contact.Email);
Assert.AreEqual("+18001234567", contact.Phone);
Assert.AreEqual("+18011234567", contact.Fax);
Assert.AreEqual("Italian Street, 10", contact.Address1);
Assert.IsEmpty(contact.Address2);
Assert.AreEqual("Roma", contact.City);
Assert.AreEqual("RM", contact.StateProvince);
Assert.AreEqual("00100", contact.PostalCode);
Assert.AreEqual("IT", contact.Country);
Assert.AreEqual(CreatedAt, contact.CreatedAt);
Assert.AreEqual(UpdatedAt, contact.UpdatedAt);
});
}
public async Task<PaginatedResponse<IEnumerable<CompanyReviewResponse>>> GetCompanyReviews(SingleData<int> request, int pageIndex, int pageSize, SystemSession session)
{
var serviceRequest = new CompanyReview
{
CompanyId = request.Data,
OffSet = pageIndex,
PageSize = pageSize
};
var response = await Task.Factory.StartNew(() => Client.UserService.getCompanyReviews(serviceRequest, session.GetSession())).ConfigureAwait(false);
var result = new PaginatedResponse<IEnumerable<CompanyReviewResponse>>
{
HasNextPage = response.HasNextPage,
Page = response.CompanyReviews.Select(
x => new CompanyReviewResponse
{
CompanyReviewGuid = x.CompanyReviewGUID != null ? Guid.Parse(x.CompanyReviewGUID) : Guid.Empty,
User = new UserResponse
{
UserId = x.UserId,
UserName = x.Username,
Name = x.Name,
Picture = x.PictureUrl
},
Star = x.Star,
Title = x.Title,
Comment = x.Comment,
DateCommented = x.DateCommented != null ? Convert.ToDateTime(x.DateCommented) : (DateTime?)null,
IsApproved = x.IsApproved
})
};
return result;
}
private PaginatedResponseContract <AccountStatContract> Convert(PaginatedResponse <MarginTradingAccount> accounts)
{
return(new PaginatedResponseContract <AccountStatContract>(
contents: accounts.Contents.Select(x => x.ConvertToContract()).ToList(),
start: accounts.Start,
size: accounts.Size,
totalSize: accounts.TotalSize
));
}
public async Task <IActionResult> GetFilteredListPage(QuestionFilter filter, int pageIndex, int pageSize)
{
var result = await _questionBankService.FilteredListAsync(filter);
var resultDTO = _mapper.Map <IEnumerable <QuestionDTO> >(result.Questions);
var page = new PaginatedResponse <QuestionDTO>(resultDTO, pageIndex, pageSize);
return(Ok(page.Data));
}
private ByPagesAccountBalanceHistoryResponse Convert(PaginatedResponse <IAccountBalanceChange> data, decimal totalAmount)
{
return(new ByPagesAccountBalanceHistoryResponse(
data.Contents.Select(Convert).ToList(),
data.Start,
data.Size,
data.TotalSize,
totalAmount
));
}
public async Task <PaginatedResponse <Comment> > GetPaginatedCommentsBypostIdAsync(string postId, PaginationRequest request)
{
var allComments = comments.FindAll(x => x.PostId.Equals(postId));
if (allComments == null || allComments.Count == 0)
{
return new PaginatedResponse <Comment> {
PageDetails = new PagingDetails()
}
}
;
var orderedComments = allComments.OrderByDescending(x => x.CreatedOn).ToList();
var totalCount = orderedComments.Count;
var response = new PaginatedResponse <Comment> {
PageDetails = new PagingDetails {
TotalCount = totalCount
}
};
if (request == null)
{
response.Data = orderedComments;
response.PageDetails.PageNumber = 1;
response.PageDetails.PageSize = totalCount;
return(response);
}
if (request.PageNumber <= 0)
{
request.PageNumber = 1;
}
//tODO: move it to keystore
if (request.PageSize <= 0)
{
request.PageSize = 10;
}
var totalPages = (int)Math.Ceiling((decimal)totalCount / (decimal)request.PageSize);
if (request.PageNumber > totalPages)
{
request.PageNumber = totalPages;
}
var data = orderedComments.Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize).ToList();
return(new PaginatedResponse <Comment> {
Data = data, PageDetails = new PagingDetails {
PageNumber = request.PageNumber,
PageSize = request.PageSize,
TotalCount = totalCount
}
});
}
}
public async Task <PaginatedResponse <Plant> > GetPlants(
DataContext dataContext,
int[] aanbod,
int[] soort,
int[] licht,
int[] water,
string name,
int page = 1,
string sort = "new"
)
{
var query = dataContext.Plants.Select(p => p);
//build query
if (aanbod.Length > 0)
{
query = query.Where(p => aanbod.Contains(p.Aanbod));
}
if (soort.Length > 0)
{
query = query.Where(p => soort.Contains(p.Soort));
}
if (licht.Length > 0)
{
query = query.Where(p => licht.Contains(p.Licht));
}
if (water.Length > 0)
{
query = query.Where(p => water.Contains(p.Water));
}
if (name != null)
{
query = query.Where(p =>
EF.Functions.Like(p.Name.ToLower(), $"%{name.ToLower()}%"));
}
//show only approved plants
query = query.Where(p => p.HasBeenApproved);
//sort plants by sort filter
if (sort == "a-z")
{
query = query.OrderBy(p => p.Name);
}
else if (sort == "z-a")
{
query = query.OrderByDescending(p => p.Name);
}
else
{
query = query.OrderByDescending(p => p.Creation);
}
return(await PaginatedResponse <Plant> .CreateAsync(query, page, 18));
}
public async Task<PaginatedResponse<IEnumerable<EmployeeViewResponse>>> GetEmployees(EmployeeViewRequest request, int pageIndex, int pageSize, SystemSession session)
{
var serviceRequest = new Employees
{
UserId = request.TargetUserId,
FilterId = request.FilterId,
Offset = pageIndex,
PageSize = pageSize,
SearchTerm = request.SearchTerm
};
var response = await Task.Factory.StartNew(() => Client.UserService.getEmployees(serviceRequest, session.GetSession())).ConfigureAwait(false);
var result = new PaginatedResponse<IEnumerable<EmployeeViewResponse>>
{
HasNextPage = response.HasNextPage,
Page = response.CompanyEmployeeInfos.Select(
x => new EmployeeViewResponse
{
User = new UserResponse
{
UserId = x.UserId,
UserName = x.Username,
Name = x.Firstname + " " + x.Lastname,
Picture = x.Picture
},
Position = new GeneralKvPair<int?, string>
{
Id = x.PositionId,
Value = x.Position
},
EmploymentId = x.EmploymentId,
EmployeeTypeId = x.EmployeeTypeId,
EmploymentDate = new BeginEndDate
{
BeginDate = Convert.ToDateTime(x.StartDate),
EndDate = x.EndDate != null ? Convert.ToDateTime(x.EndDate) : (DateTime?)null
},
IsExecutiveBody = x.IsExecutiveBody,
Added = x.Added != null ? Convert.ToDateTime(x.Added) : (DateTime?)null,
IsApproved = x.ApprovedStatus
})
};
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 async Task<PaginatedResponse<IEnumerable<NotificationResponse>>> GetNotificationList(NotificationRequest request, int pageIndex, int pageSize, SystemSession session)
{
var serviceRequest = new NotificationMob { TypeId = request.FilterType, RequestDirection = request.RequestDirection, NrTypes = request.NotificationRequestTypes, DisplayOnlyId = (int)request.NotificationRequestId.GetValueOrDefault(), SetAsRead = true, PageIndex = pageIndex, PageSize = pageSize, UserId = session.UserId, UserName = session.UserName };
var response = await Task.Factory.StartNew(() => Client.UserService.getAllNotifications(serviceRequest, session.GetSession())).ConfigureAwait(false);
var result =
new PaginatedResponse<IEnumerable<NotificationResponse>>
{
HasNextPage = response.HasNextPage,
Page =
response.Notifications.Select(
x =>
new NotificationResponse
{
NotificationId = x.NotificationId,
NotifierId = x.UserId,
NotifierUserName = x.UserName,
ReadDate = Convert.ToDateTime(x.ReadDate),
SentDate = Convert.ToDateTime(x.SentDate),
TypeId = x.TypeId,
Type = x.Type,
Name = x.Name,
Picture = x.PictureUrl,
Title = x.Title,
Notification = x.Notification,
MutualFriendId = x.MutualFrdId,
MutualFriendName = x.MutualFrdName,
MutualFriendCount = x.MutualFrdCount,
GroupId = x.GroupId,
GroupName = x.GroupName,
EventId = x.EventId,
EventName = x.EventName,
ClickedDate = Convert.ToDateTime(x.ClickDate)
})
};
return result;
}
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 async Task<PaginatedResponse<IEnumerable<ThumbsForSkillDetailResponse>>> GetThumbsForSkillDetail(ThumbsForSkillDetailRequest request, int pageIndex, int pageSize, SystemSession session)
{
var serviceRequest = new Kauwa.Skill
{
UserIdOrName = request.TargetUser,
SkillTypeId = request.SkillTypeId,
Offset = pageIndex,
PageSize = pageSize
};
var response = await Task.Factory.StartNew(() => Client.UserService.thumbsForSkillDetails(serviceRequest, session.GetSession())).ConfigureAwait(false);
var result = new PaginatedResponse<IEnumerable<ThumbsForSkillDetailResponse>>
{
HasNextPage = response.HasNextPage,
Page = response.Skills.Select(
x => new ThumbsForSkillDetailResponse
{
User = new UserResponse
{
UserId = x.UserId,
UserName = x.Username,
Name = x.Name,
Picture = x.Picture
},
UporDown = x.ThumbsUpOrDown
})
};
return result;
}
public async Task<PaginatedResponse<IEnumerable<ResignationViewResponse>>> GetResignationRequest(int pageIndex, int pageSize, SystemSession session)
{
var serviceRequest = new Employees
{
UserId = session.UserId,
Offset = pageIndex,
PageSize = pageSize
};
var response = await Task.Factory.StartNew(() => Client.UserService.getResignationRequest(serviceRequest, session.GetSession())).ConfigureAwait(false);
var result = new PaginatedResponse<IEnumerable<ResignationViewResponse>>
{
HasNextPage = response.HasNextPage,
Page = response.Employees.Select(
x => new ResignationViewResponse
{
PersonEmploymentId = x.PersonEmploymentId,
User = new UserResponse
{
UserId = x.UserId,
UserName = x.Username,
Name = x.Name,
Picture = x.Picture
},
Position = x.Position,
EndDate = x.EndDate != null ? Convert.ToDateTime(x.EndDate) : (DateTime?)null
})
};
return result;
}
