public CollectionResponse<Contact> GetContacts()
{
var response = new CollectionResponse<Contact>();
try
{
var contacts = _repository.GetCollection(_appSettings.ContactsCollectionName);
if (contacts != null)
{
foreach (var contact in contacts)
{
if (contact.Identifiers == null)
{
contact.Personal = new Person() { FirstName = "Anonymous" };
}
}
response.Collection = contacts;
}
}
catch (Exception ex)
{
response.Errors.AddRange(ex.ToCollection());
}
return response;
}
public async Task GetFlatForRentAnnouncementsAsync_Should_Return_OkObjectResult_With_CollectionResponse_With_FlatForRentAnnouncementResponses()
{
var flatForRentAnnouncementOutputQueries = new List <FlatForRentAnnouncementOutputQuery>
{
new FlatForRentAnnouncementOutputQuery(Guid.NewGuid(), "Title", "http://sourceUrl",
Guid.NewGuid(), DateTimeOffset.UtcNow, "Description", 100, NumberOfRoomsEnumeration.One,
new List <Guid>())
};
var collectionOutputQuery =
new CollectionOutputQuery <FlatForRentAnnouncementOutputQuery>(flatForRentAnnouncementOutputQueries.Count, flatForRentAnnouncementOutputQueries);
var flatForRentAnnouncementResponses = flatForRentAnnouncementOutputQueries.Select(output =>
new FlatForRentAnnouncementResponse(output.Id, output.Title, output.SourceUrl, output.CityId,
output.Created, output.Description, output.Price,
FlatForRentAnnouncementProfile.ConvertToNumberOfRoomsEnum(output.NumberOfRooms),
output.CityDistricts))
.ToList();
var collectionResponse = new CollectionResponse <FlatForRentAnnouncementResponse>(flatForRentAnnouncementResponses.Count, flatForRentAnnouncementResponses);
_getFlatForRentAnnouncementsQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetFlatForRentAnnouncementsInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(collectionOutputQuery);
_mapperMock
.Setup(x => x.Map <CollectionOutputQuery <FlatForRentAnnouncementOutputQuery>, CollectionResponse <FlatForRentAnnouncementResponse> >(It.IsAny <CollectionOutputQuery <FlatForRentAnnouncementOutputQuery> >()))
.Returns(collectionResponse);
var result = await _controller.GetFlatForRentAnnouncementsAsync(new GetFlatForRentAnnouncementsRequest());
var okResult = result.As <OkObjectResult>();
okResult.Value.Should().BeEquivalentTo(collectionResponse);
}
public ActionResult <CollectionResponse <Transaction> > GetReport([FromQuery] TransactionReportRequest request)
{
var response = new CollectionResponse <Transaction>();
try
{
var transactions = _dacTransaction
.Where(t =>
t.CreatedDate.Date >= request.StartDate.Date &&
t.CreatedDate.Date <= request.EndDate.Date &&
(string.IsNullOrEmpty(request.PaymentStatus) || t.PaymentStatus.Equals(request.PaymentStatus))
)
.OrderByDescending(t => t.CreatedDate);
response.Collections = TranslateToModel(transactions);
response.Status.SetSuccess();
}
catch (Exception e)
{
Console.WriteLine(e);
response.Status.SetError(e);
}
return(response);
}
public CollectionResponse <IncomingDto> GetConsultansIncoming(IncomingInputDto input)
{
if (input.Start > input.End)
{
throw new Exception("Invalid date range");
}
CollectionResponse <IncomingDto> result = new CollectionResponse <IncomingDto>();
foreach (var consultant in input.Consultants)
{
var userName = consultant.CoUsuario;
var userExist = userRepository.Get(userName) != null;
if (!userExist)
{
continue;
}
IncomingDto incomingDto = new IncomingDto();
incomingDto.CoUsuario = userName;
incomingDto.NoUsuario = ResolveUserFullname(userName);
var incomings = this.ResolveIncomingByDate(userName, input.Start, input.End);
incomings.ForEach(item => incomingDto.IncomingList.Add(item));
result.Items.Add(incomingDto);
}
result.SourceTotal = result.Items.Count;
CalculateIndividualEarningPercents(result);
return(result);
}
private List <CollectionItemResponse> GetAllContentForCollection(string collectionSlug)
{
CollectionResponse collection = _client.Collections.GetCollection(collectionSlug, true, true, true);
List <CollectionItemResponse> flattenedCollectionList = GetFlattenedListOfContent(collection.Items);
return(flattenedCollectionList);
}
public CollectionResponse <Contact> GetContacts()
{
var response = new CollectionResponse <Contact>();
try
{
var contacts = _repository.GetCollection(_appSettings.ContactsCollectionName);
if (contacts != null)
{
foreach (var contact in contacts)
{
if (contact.Identifiers == null)
{
contact.Personal = new Person()
{
FirstName = "Anonymous"
};
}
}
response.Collection = contacts;
}
}
catch (Exception ex)
{
response.Errors.AddRange(ex.ToCollection());
}
return(response);
}
public CollectionResponse <ConsultantDto> GetAll(PaginationResult input)
{
if (input.SkipCount < 0)
{
input.SkipCount = 0;
}
if (input.MaxCount < 0)
{
input.MaxCount = 0;
}
if (string.IsNullOrEmpty(input.SortBy))
{
input.SortBy = "NoUsuario";
}
// Apply business logic
IQueryable <CaoUsuario> entities = GetFiteredResult();
var propertyInfo = typeof(CaoUsuario).GetProperty(input.SortBy);
List <CaoUsuario> result = entities.AsEnumerable().OrderBy(t => propertyInfo.GetValue(t, null)).Skip(input.SkipCount).Take(input.MaxCount).ToList();
var response = new CollectionResponse <ConsultantDto> {
SourceTotal = entities.Count()
};
response.Items.AddRange(mapper.Map <List <CaoUsuario>, List <ConsultantDto> >(result));
return(response);
}
private static async Task <string> PrepareExpectedResponseAsync(GetAccountsRequest getAccountsRequest, RivaIdentityDbContext context)
{
var accountEntities = await context.Accounts
.Where(x => x.Email.ToLower().StartsWith(getAccountsRequest.Email.ToLower()) && x.Confirmed == getAccountsRequest.Confirmed)
.OrderBy(x => x.Email)
.Skip(getAccountsRequest.PageSize.Value * (getAccountsRequest.Page.Value - 1))
.Take(getAccountsRequest.PageSize.Value)
.ToListAsync();
var totalCount = await context.Accounts
.LongCountAsync(x => x.Email.ToLower().StartsWith(getAccountsRequest.Email.ToLower()) && x.Confirmed == getAccountsRequest.Confirmed);
var getAccountsCollectionItemResponses = accountEntities.Select(x =>
new GetAccountsCollectionItemResponse(x.Id, x.Email, x.Confirmed, x.Created,
!string.IsNullOrWhiteSpace(x.PasswordHash), x.LastLogin));
var collectionResponse = new CollectionResponse <GetAccountsCollectionItemResponse>(totalCount, getAccountsCollectionItemResponses);
var settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new DefaultTestPlatformContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
},
Converters = new List <JsonConverter> {
new StringEnumConverter()
}
};
return(JsonConvert.SerializeObject(collectionResponse, settings));
}
public ActionResult <CollectionResponse <ProductCategory> > Get(string id)
{
var response = new CollectionResponse <ProductCategory>();
try
{
var categories = (string.IsNullOrEmpty(id)
? _dacProductCategory.All()
: new[] { _dacProductCategory.Single(id) })
.ToList();
if (!categories.Any())
{
throw new Exception("result empty");
}
response.Collections = categories
.Select(c => new ProductCategory
{
Id = c.Id,
Name = c.Name
})
.ToList();
response.Status.SetSuccess();
}
catch (Exception e)
{
response.Status.SetError(e);
}
return(response);
}
public async Task GetStatesAsync_Should_Return_OkObjectResult_With_CollectionResponse_With_StateResponses()
{
var getStatesRequest = new GetStatesRequest
{
Page = 1,
PageSize = 100,
Name = "Name",
PolishName = "PolishName",
Sort = "name:asc"
};
var getStatesInputQuery = new GetStatesInputQuery(getStatesRequest.Page,
getStatesRequest.PageSize, getStatesRequest.Sort, getStatesRequest.Name, getStatesRequest.PolishName);
var stateOutputQuery = new StateOutputQuery(Guid.NewGuid(), Array.Empty <byte>(), "Name", "PolishName");
var stateOutputQueries = new Collection <StateOutputQuery> {
stateOutputQuery
};
var collectionOutputQuery = new CollectionOutputQuery <StateOutputQuery>(stateOutputQueries.Count, stateOutputQueries);
var stateResponses = stateOutputQueries.Select(x => new StateResponse(x.Id, x.RowVersion, x.Name, x.PolishName));
var collectionResponse = new CollectionResponse <StateResponse>(stateOutputQueries.Count, stateResponses);
_mapperMock.Setup(x => x.Map <GetStatesRequest, GetStatesInputQuery>(It.IsAny <GetStatesRequest>()))
.Returns(getStatesInputQuery);
_getStatesQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetStatesInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(collectionOutputQuery);
_mapperMock
.Setup(x => x.Map <CollectionOutputQuery <StateOutputQuery>, CollectionResponse <StateResponse> >(It.IsAny <CollectionOutputQuery <StateOutputQuery> >()))
.Returns(collectionResponse);
var result = await _controller.GetStatesAsync(getStatesRequest);
var okResult = result.As <OkObjectResult>();
okResult.Value.Should().BeEquivalentTo(collectionResponse);
}
private void SetSignedIn(AccountResponse account)
{
ConfigModel.SigninProvider = account.Provider;
ConfigModel.Save();
MainWindowVM.SetSignedIn(account);
Api.SetUserId(account.MtgaHelperUserId);
if (MainWindowVM.CanUpload == false || MainWindowVM.Account.IsAuthenticated == false)
{
return;
}
Task.Factory.StartNew(() =>
{
try
{
MainWindowVM.WrapNetworkStatus(NetworkStatusEnum.Downloading, () =>
{
CollectionResponse collection = Api.GetCollection(MainWindowVM.Account.MtgaHelperUserId);
MainWindowVM.SetCollection(collection);
RefreshRareDraftingInfo();
});
UploadLogFile();
}
catch (HttpRequestException)
{
MainWindowVM.SetProblemServerUnavailable();
}
});
}
public CollectionData(CollectionResponse collection, string userId)
{
Id = collection.Id;
UserId = userId;
Name = collection.Name;
OrganizationId = collection.OrganizationId;
}
private static async Task <string> PrepareExpectedResponseAsync(RivaAdministrativeDivisionsDbContext context, GetCitiesRequest getCitiesRequest)
{
var cityEntities = await context.Cities
.Where(x =>
x.Name.ToLower().StartsWith(getCitiesRequest.Name.ToLower()) &&
x.PolishName.ToLower().StartsWith(getCitiesRequest.PolishName.ToLower()) &&
x.StateId == getCitiesRequest.StateId)
.OrderBy(x => x.Name)
.Skip(getCitiesRequest.PageSize.Value * (getCitiesRequest.Page.Value - 1))
.Take(getCitiesRequest.PageSize.Value)
.ToListAsync();
var cityResponses = cityEntities.Select(x => new CityResponse(x.Id, x.RowVersion, x.Name, x.PolishName, x.StateId));
var totalCount = await context.Cities.LongCountAsync(x =>
x.Name.ToLower().StartsWith(getCitiesRequest.Name.ToLower()) &&
x.PolishName.ToLower().StartsWith(getCitiesRequest.PolishName.ToLower()) &&
x.StateId == getCitiesRequest.StateId);
var collectionResponse = new CollectionResponse <CityResponse>(totalCount, cityResponses);
var settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new DefaultTestPlatformContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
}
};
return(JsonConvert.SerializeObject(collectionResponse, settings));
}
private static async Task <string> PrepareExpectedResponseAsync(ICosmosStore <FlatForRentAnnouncementEntity> cosmosStore)
{
var flatForRentAnnouncementEntities = await cosmosStore.Query().ToListAsync();
var getFlatForRentAnnouncementsCollectionItemResponses = flatForRentAnnouncementEntities.Select(
flatForRentAnnouncementEntity => new FlatForRentAnnouncementResponse(
flatForRentAnnouncementEntity.Id,
flatForRentAnnouncementEntity.Title,
flatForRentAnnouncementEntity.SourceUrl,
flatForRentAnnouncementEntity.CityId,
flatForRentAnnouncementEntity.Created,
flatForRentAnnouncementEntity.Description,
flatForRentAnnouncementEntity.Price,
FlatForRentAnnouncementProfile.ConvertToNumberOfRoomsEnum(flatForRentAnnouncementEntity
.NumberOfRooms.ConvertToEnumeration()),
flatForRentAnnouncementEntity.CityDistricts));
var collectionResponse =
new CollectionResponse <FlatForRentAnnouncementResponse>(flatForRentAnnouncementEntities.Count, getFlatForRentAnnouncementsCollectionItemResponses);
var settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new DefaultTestPlatformContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
},
Converters = new List <JsonConverter> {
new IsoDateTimeConverter(), new StringEnumConverter()
}
};
return(JsonConvert.SerializeObject(collectionResponse, settings));
}
public void DecodeResponse()
{
CollectionResponseDecoder <Greeting, EmptyRecord> decoder = new CollectionResponseDecoder <Greeting, EmptyRecord>();
Dictionary <string, object> data = new Dictionary <string, object>()
{
{
"elements", new List <object>()
{
new Dictionary <string, object>()
{
{ "id", 123 },
{ "message", "hello" },
{ "tone", "FRIENDLY" }
},
new Dictionary <string, object>()
{
{ "id", 234 },
{ "message", "world" },
{ "tone", "SINCERE" }
}
}
},
{
"paging", new Dictionary <string, object>()
{
{ "count", 0 },
{ "start", 0 },
{ "links", new List <object>()
{
} }
}
}
};
Dictionary <string, string> headers = new Dictionary <string, string>()
{
{ "foo", "bar" }
};
HttpResponse httpResponse = new HttpResponse(200, headers, null, null);
TransportResponse transportResponse = new TransportResponse(data, httpResponse);
CollectionResponse <Greeting, EmptyRecord> response = decoder.DecodeResponse(transportResponse);
Assert.AreEqual(2, response.elements.Count);
Assert.AreEqual("bar", response.headers["foo"][0]);
Assert.IsNotNull(response.paging);
Assert.IsNull(response.metadata);
Assert.AreEqual(123, response.elements[0].id);
Assert.AreEqual("hello", response.elements[0].message);
Assert.AreEqual(Tone.Symbol.FRIENDLY, response.elements[0].tone.symbol);
Assert.AreEqual(234, response.elements[1].id);
Assert.AreEqual("world", response.elements[1].message);
Assert.AreEqual(Tone.Symbol.SINCERE, response.elements[1].tone.symbol);
}
//[TestMethod]
public void TestFilterClause()
{
RESTUrlBuilder <ListItem> queryBuilder = new RESTUrlBuilder <ListItem>();
string filterQuery = queryBuilder.BuildFilterClause(li => li.Id == 1);
SPOHttpClient spoClient = new SPOHttpClient(login, password, site);
CollectionResponse <ListItem> items = spoClient.GetData <CollectionResponse <ListItem> >("/_api/web/lists/getByTitle('Umowy')/items?$filter=" + filterQuery);
}
public ActionResult TopicExplorer(string collectionSlug, string bucketSlug, string contentSlug)
{
CollectionResponse response = _client.Collections.GetCollection(collectionSlug, false, false, false);
ViewData["Title"] = response.Title;
return(View());
}
public static CollectionResponse <T> ToCollecionResponse <T>(this IEnumerable <T> collecion)
where T : class, IResponseContext
{
var resaultCollecion = new CollectionResponse <T>();
resaultCollecion.AddRange(collecion);
return(resaultCollecion);
}
private static void CalculateIndividualEarningPercents(CollectionResponse <IncomingDto> result)
{
float totalOverAll = 0;
result.Items.ForEach(incoming => totalOverAll += incoming.TotalPersonalEarnings);
foreach (var item in result.Items)
{
item.EarningPercent = 100 * item.TotalPersonalEarnings / totalOverAll;
}
}
public async Task <CollectionResponse <Epic> > GetEpicsAsync()
{
var epicEntities = await _epicRepository.SearchForMultipleItemsAsync();
var collectionResponse = new CollectionResponse <Epic>
{
Items = epicEntities.Select(_mapper.Map <Epic>).ToList(),
};
return(collectionResponse);
}
public async Task <CollectionResponse <Team> > GetTeamsAsync()
{
var teamEntities = await _teamRepository.SearchForMultipleItemsAsync();
var collectionResponse = new CollectionResponse <Team>
{
Items = teamEntities.Select(_mapper.Map <Team>).ToList(),
};
return(collectionResponse);
}
public async Task <CollectionResponse <Project> > GetProjectsAsync()
{
var projectEntities = await _projectRepository.SearchForMultipleItemsAsync();
var collectionResponse = new CollectionResponse <Project>
{
Items = projectEntities.Select(_mapper.Map <Project>).ToList(),
};
return(collectionResponse);
}
public async Task <CollectionResponse <Sprint> > GetSprintsAsync()
{
var sprintEntities = await _sprintRepository.SearchForMultipleItemsAsync();
var collectionResponse = new CollectionResponse <Sprint>
{
Items = sprintEntities.Select(_mapper.Map <Sprint>).ToList(),
};
return(collectionResponse);
}
public async Task <CollectionResponse <Story> > GeStoriesAsync()
{
var storyEntities = await _storyRepository.SearchForMultipleItemsAsync();
var collectionResponse = new CollectionResponse <Story>
{
Items = storyEntities.Select(_mapper.Map <Story>).ToList(),
};
return(collectionResponse);
}
public CollectionResponse <Reservation> GetAll()
{
var entities = this.repository.GetAll();
var result = entities.ToList();
var response = new CollectionResponse <Reservation> {
SourceTotal = entities.Count()
};
response.Items.AddRange(result);
return(response);
}
public CollectionResponse <Contact> GetAll()
{
var entities = this.repository.GetAll();
var result = entities.OrderBy(t => t.Name);
var response = new CollectionResponse <Contact> {
SourceTotal = entities.Count()
};
response.Items.AddRange(result);
return(response);
}
public async Task <CollectionResponse <User> > GetUsersAsync()
{
var userEntities = await _userRepository.SearchForMultipleItemsAsync();
var collectionResponse = new CollectionResponse <User>
{
Items = userEntities.Select(_mapper.Map <User>).ToList(),
};
return(collectionResponse);
}
public ActionResult <CollectionResponse <Transaction> > Update(Transaction request)
{
var response = new CollectionResponse <Transaction>();
try
{
var transaction = GetTransaction(request.Id);
if (transaction.PaymentStatus.Equals(Constant.PaymentStatus.Paid))
{
throw new Exception("this transaction already paid");
}
if (transaction.PaymentStatus != request.PaymentStatus)
{
transaction.PaymentStatus = GetPaymentStatus(request.PaymentStatus);
}
if (transaction.PaymentType != request.PaymentType)
{
transaction.PaymentType = ValidatePaymentType(request.PaymentType);
}
if (transaction.TotalPrice != request.TotalPrice && request.SelectedProducts.Any())
{
_dacSelectedProduct.DeleteWhere(sp => sp.TransactionId.Equals(transaction.Id));
transaction.SelectedProducts =
FillSelectedProducts(request.SelectedProducts, transaction.Id, out var totalPrice);
transaction.TotalPrice = totalPrice;
}
if (transaction.DiscountCode != request.Discount.Code && !string.IsNullOrEmpty(request.Discount.Code))
{
transaction.DiscountCode = FillDiscount(request.Discount.Code, transaction.TotalPrice,
out var discountValue);
transaction.DiscountValue = discountValue;
}
_dacTransaction.Update(transaction);
_dacTransaction.Commit();
response.Collections = Get(transaction.Id).Value.Collections;
response.Status.SetSuccess();
}
catch (Exception e)
{
Console.WriteLine(e);
response.Status.SetError(e.Message);
}
return(response);
}
private static async Task <IEnumerable <Part> > GetFilmCollectionAsync(int collection_id)
{
RestRequest request = new RestRequest("/collection/{collection_id}");
request.AddParameter("api_key", API_KEY);
request.AddUrlSegment("collection_id", collection_id);
CollectionResponse response = await client.GetAsync <CollectionResponse>(request);
return(response.parts?
.OrderByDescending(p => !string.IsNullOrEmpty(p.release_date))
.ThenBy(p => p.release_date));
}
public async Task Should_retrieve_users_game_collection()
{
CollectionResponse response = await bgg.GetCollectionAsync(new CollectionRequest(
USERNAME,
stats : true));
Assert.True(response.Succeeded);
CollectionResponse.ItemCollection items = response.Result;
Assert.NotNull(items);
Assert.Equal(56, items.Count);
}
public object EncodeData(IResponse response)
{
if (response is CollectionResponse <IResponse> )
{
CollectionResponse <IResponse> collectionResponse = (CollectionResponse <IResponse>)response;
var items = collectionResponse.Items();
string collectionResponseJson = JsonConvert.SerializeObject(items, new JsonApiSerializerSettings());
return(JsonConvert.DeserializeObject <dynamic[]>(collectionResponseJson, new JsonApiSerializerSettings()));
}
string responseJson = JsonConvert.SerializeObject(response, new JsonApiSerializerSettings());
return(JsonConvert.DeserializeObject(responseJson, new JsonApiSerializerSettings()));
}
public CollectionResponse<Interaction> GetInteractions()
{
var response = new CollectionResponse<Interaction>();
try
{
response.Collection = _repository.GetCollection(_appSettings.InteractionsCollectionName);
}
catch (Exception ex)
{
response.Errors.AddRange(ex.ToCollection());
}
return response;
}
public void SetupGetInteractions(CollectionResponse<Interaction> response)
{
InteractionService.Setup(s => s.GetInteractions()).Returns(response).Verifiable();
}
public void SetupGetContacts(CollectionResponse<Contact> response)
{
ContactService.Setup(s => s.GetContacts()).Returns(response).Verifiable();
}
