Exemplo n.º 1
0
        public CustomerCollectionResponse Fetch(CustomerQueryCollectionRequest request)
        {
            base.FixupLimitAndPagingOnRequest(request);

            var totalItemCount  = 0;
            var sortExpression  = RepositoryHelper.ConvertStringToSortExpression(EntityType, request.Sort);
            var includeFields   = RepositoryHelper.ConvertStringToExcludedIncludedFields(EntityType, request.Select);
            var prefetchPath    = RepositoryHelper.ConvertStringToPrefetchPath(EntityType, request.Include, request.Select);
            var predicateBucket = RepositoryHelper.ConvertStringToRelationPredicateBucket(EntityType, request.Filter, request.Relations);

            EntityCollection <CustomerEntity> entities;

            using (var adapter = DataAccessAdapterFactory.NewDataAccessAdapter())
            {
                OnBeforeFetchCustomerQueryCollectionRequest(adapter, request, sortExpression, includeFields, prefetchPath, predicateBucket,
                                                            request.PageNumber, request.PageSize, request.Limit);
                entities = base.Fetch(adapter, sortExpression, includeFields, prefetchPath, predicateBucket,
                                      request.PageNumber, request.PageSize, request.Limit, out totalItemCount);
                OnAfterFetchCustomerQueryCollectionRequest(adapter, request, entities, sortExpression, includeFields, prefetchPath, predicateBucket,
                                                           request.PageNumber, request.PageSize, request.Limit, totalItemCount);
            }
            var response = new CustomerCollectionResponse(entities.ToDtoCollection(), request.PageNumber,
                                                          request.PageSize, totalItemCount);

            return(response);
        }
Exemplo n.º 2
0
        public static async Task ContinuationAtNullToken(string payload)
        {
            using (Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(payload)))
            {
                CustomerCollectionResponse response = await JsonSerializer.DeserializeAsync <CustomerCollectionResponse>(stream, new JsonSerializerOptions { IgnoreNullValues = true });

                Assert.Equal(50, response.Customers.Count);
            }
        }
Exemplo n.º 3
0
    static async Task Main(string[] args)
    {
        AutoFaker.Configure(builder =>
        {
            builder.WithConventions();
        });

        string runId      = DateTime.UtcNow.ToString("yyyy-MM-dd-HHmmss");
        string outputDir  = Path.Combine(AppContext.BaseDirectory, "../../../examples", runId);
        string outputFile = Path.Combine(outputDir, runId + ".txt");

        if (!Directory.Exists(outputDir))
        {
            Directory.CreateDirectory(outputDir);
        }

        using (var output = File.OpenWrite(outputFile))
            using (var writer = new StreamWriter(output))
            {
                for (int i = 0; i < 1000; i++)
                {
                    var stream = new MemoryStream();

                    try
                    {
                        var customers = new CustomerCollectionResponse
                        {
                            Customers = Enumerable.Range(0, 50).Select(i => CustomerDataGenerator.CreateCustomer()).ToList()
                        };

                        await JsonSerializer.SerializeAsync(stream, customers);

                        stream.Position = 0;

                        var deserialized = await JsonSerializer.DeserializeAsync <CustomerCollectionResponse>(stream, s_serializerOptions);

                        writer.WriteLine($"{i:0000}: Reading Json from stream - deserialized {deserialized.Customers.Count} customer records.");
                        Console.WriteLine($"{i:0000}: Reading Json from stream - deserialized {deserialized.Customers.Count} customer records.");
                    }
                    catch (Exception e)
                    {
                        writer.WriteLine($"{i:0000}: Error:{Environment.NewLine}{e}");
                        Console.WriteLine($"{i:0000}: Error:{Environment.NewLine}{e}");

                        using (var file = File.OpenWrite(Path.Combine(outputDir, $"{runId}-{i:0000}.json")))
                        {
                            await file.WriteAsync(stream.ToArray());
                        }
                    }
                }
            }
    }
Exemplo n.º 4
0
        public override async Task <CustomerCollectionResponse> GetCustomers(Empty request, ServerCallContext context)
        {
            var result = new CustomerCollectionResponse();

            try
            {
                var costumers = await _costumerRepository.GetAll();

                foreach (var costumer in costumers)
                {
                    costumer.CaesarDecipherObject(_keyCaesarEncipher);

                    var current = new CustomerRequest();
                    current.IdNumber   = costumer.IdNumber;
                    current.Address    = costumer.Address;
                    current.BirthDate  = costumer.BirthDate.ToString();
                    current.City       = costumer.City;
                    current.Country    = costumer.Country;
                    current.Email      = costumer.Email;
                    current.FirsName   = costumer.FirsName;
                    current.IdNumber   = costumer.IdNumber;
                    current.LastName   = costumer.LastName;
                    current.MiddleName = costumer.MiddleName;
                    current.Movil      = costumer.Movil;
                    current.Phone      = costumer.Phone;

                    result.Customers.Add(current);
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, $"ERROR: GETALL Costumer");
                result.Message = $"ERROR: GETALL Costumer";
            }
            return(result);
        }