コード例 #1
0
        public PaginatedDto <UserDto> GetUsers(PaginatedRequestCommand cmd)
        {
            var users = _membershipService.GetUsers(cmd.Page, cmd.Take);

            return(users.ToPaginatedDto(
                       users.Select(user => user.ToUserDto())));
        }
コード例 #2
0
        public PaginatedDto <ShipmentDto> GetShipments(PaginatedRequestCommand cmd)
        {
            var shipments = _shipmentService
                            .GetShipments(cmd.Page, cmd.Take);

            return(shipments.ToPaginatedDto(shipments.Select(sh => sh.ToShipmentDto())));
        }
コード例 #3
0
        public async Task <PaginatedDto <ShipmentDto> > GetShipmentsAsync(PaginatedRequestCommand paginationCmd)
        {
            var parameters   = new { key = _affiliateKey, page = paginationCmd.Page, take = paginationCmd.Take };
            var responseTask = base.GetAsync(BaseUriTemplate, parameters);
            var shipments    = await HandleResponseAsync(responseTask);

            return(shipments);
        }
コード例 #4
0
        public PaginatedDto <AffiliateDto> GetAffiliates(PaginatedRequestCommand cmd)
        {
            var affiliates = _shipmentService.GetAffiliates(
                cmd.Page, cmd.Take);

            return(affiliates.ToPaginatedDto(
                       affiliates.Select(af => af.ToAffiliateDto())));
        }
コード例 #5
0
        public async Task <PaginatedDto <OrderDto> > GetOrdersAsync(PaginatedRequestCommand paginationCmd)
        {
            var parameters   = new { key = _clientKey, page = paginationCmd.Page, take = paginationCmd.Take };
            var responseTask = base.GetAsync(BaseUriTemplate, parameters);

            var orders = await HandleResponseAsync(responseTask);

            return(orders);
        }
コード例 #6
0
ファイル: SortFactory.cs プロジェクト: leandrolustosa/astove
        public static SortOptions GenerateSortOptions(PaginatedRequestCommand model)
        {
            var sortOptions = new SortOptions
            {
                Fields     = (model.OrdersBy == null || model.OrdersBy.Length == 0) ? new[] { "Id" } : model.OrdersBy,
                Directions = (model.Directions == null || model.Directions.Length == 0) ? new[] { "asc" } : model.Directions
            };

            return(sortOptions);
        }
コード例 #7
0
        public async Task <PaginatedDto <ShipmentTypeDto> > GetShipmentTypesAsync(PaginatedRequestCommand paginationCmd)
        {
            using (var apiResponse = await base.GetAsync(BaseUriTemplate, paginationCmd)) {
                if (apiResponse.IsSuccess)
                {
                    return(apiResponse.Model);
                }

                throw new HttpApiRequestException(
                          string.Format(ErrorMessages.HttpRequestErrorFormat, (int)apiResponse.Response.StatusCode, apiResponse.Response.ReasonPhrase),
                          apiResponse.Response.StatusCode, apiResponse.HttpError);
            }
        }
コード例 #8
0
        public Task <PaginatedDto <TModel> > GetEntitiesAsync(PaginatedRequestCommand request)
        {
            var parameters = new {
                page = request.Page,
                take = request.Take,
                type = request.Type,
                hasDefaultConditions = request.HasDefaultConditions,
                directions           = (request.Directions == null) ? new string[0] : request.Directions,
                ordersBy             = (request.OrdersBy == null) ? new string[0] : request.OrdersBy
            };

            var responseTask = base.GetAsync(BaseUriTemplate, parameters);

            return(HandleResponseAsync(responseTask).ContinueWith(t => { return t.Result; }));
        }
コード例 #9
0
        public virtual IHttpActionResult Get(PaginatedRequestCommand cmd)
        {
            cmd.FilterInternalDictionary = new Dictionary <string, object>();

            this.ListSelecting(cmd);

            var attr = typeof(TModel).GetCustomAttributes(true).OfType <DataEntityAttribute>().FirstOrDefault();

            if (cmd.Type.Equals(AInBox.Astove.Core.Enums.EnumUtility.GetEnumText(GetTypes.PagedGrid), StringComparison.CurrentCultureIgnoreCase))
            {
                try
                {
                    var list = this.Service.GetEntities(this.Container, cmd, typeof(TModel), cmd.OrdersBy, cmd.Directions, (attr != null) ? attr.Include : null);

                    var paginatedModel = list.ToPaginatedModel <TModel>(null, null);
                    SetViews(paginatedModel.Items);

                    paginatedModel.ColumnDefinitions = ColumnFactory.GenerateColumnDefinitions <TModel>(ActionEnum.List).ToArray();
                    paginatedModel.Condition         = new Condition();

                    this.ListSelected(paginatedModel);

                    return(Ok(paginatedModel));
                }
                catch (Exception ex)
                {
                    return(InternalServerError(ex));
                }
            }

            try
            {
                var entities = this.Service.GetEntities(this.Container, cmd, typeof(TModel), cmd.OrdersBy, cmd.Directions, (attr != null) ? attr.Include : null);
                var paged    = entities.ToPaginatedModel <TModel>(null, null);
                SetViews(paged.Items);

                paged.ColumnDefinitions = ColumnFactory.GenerateColumnDefinitions <TModel>(ActionEnum.List).ToArray();
                paged.Condition         = new Condition();

                this.ListSelected(paged);

                return(Ok(paged));
            }
            catch (Exception ex)
            {
                return(InternalServerError(ex));
            }
        }
コード例 #10
0
        public void Delete(int id, int quantidadeEsperada)
        {
            BaseResultModel result = null;
            PaginatedMongoModel <ListaEmpresaMongoModel> listResult = null;

            "Quando solicitado editar empresa com id {0}"
            .x(async() => {
                var user = await service.MongoService.GetMongoObjectByParentId <PessoaMongoModel>(1);
                if (user == null)
                {
                    result = new BaseResultModel {
                        IsValid = false, StatusCode = 404, Message = "Profile não encontrado"
                    };
                }
                else
                {
                    var model = await service.MongoService.GetMongoObjectByParentId <EmpresaClienteMongoModel>(id);
                    result    = await service.DeleteEmpresaBindingModel(new DeleteBindingModel {
                        Id = model.Id
                    });
                }
            });

            "Então o result deve ser válido e o objeto deve ter sido excluído"
            .x(() => {
                Assert.NotNull(result);
                Assert.Equal(result.IsValid, true);
            });

            "Quando novamente solicitado obter todas as empresas"
            .x(async() => {
                var model = new PaginatedRequestCommand {
                    Page = 1, Take = 1000, Type = EnumUtility.GetEnumText(GetTypes.Paged)
                };
                listResult = await service.GetAll <ListaEmpresaMongoModel>(container, model);
            });

            "Então a quantidade de empresas deve ser {1}"
            .x(() => {
                Assert.Equal(listResult.Items.Count(), quantidadeEsperada);

                Reset(true);
            });
        }
コード例 #11
0
        public void GetAll(int quantidadeEsperada)
        {
            Reset(true);

            PaginatedMongoModel <ListaEmpresaMongoModel> result = null;

            "Quando solicitado obter todas as empresas"
            .x(async() => {
                var model = new PaginatedRequestCommand {
                    Page = 1, Take = 1000, Type = EnumUtility.GetEnumText(GetTypes.Paged)
                };
                result = await service.GetAll <ListaEmpresaMongoModel>(container, model);
            });

            "Então a quantidade de empresas deve ser {0}"
            .x(() => {
                Assert.Equal(result.Items.Count(), quantidadeEsperada);
            });
        }
コード例 #12
0
        public void PostInvalid(int tipo, int quantidadeEsperada)
        {
            PostResultModel result = null;
            PaginatedMongoModel <ListaEmpresaMongoModel> listResult = null;

            "Quando solicitado adicionar empresa com dados inválidos então deve retornar exceção {1}"
            .x(() => {
                Assert.ThrowsAsync <AstoveModelInvalidException <Empresa> >(async() => {
                    var user = await service.MongoService.GetMongoObjectByParentId <PessoaMongoModel>(1);
                    if (user == null)
                    {
                        result = new PostResultModel {
                            IsValid = false, StatusCode = 404, Message = "Profile não encontrado"
                        };
                    }
                    else
                    {
                        var model = await service.GetPostEmpresaBindingModel(new GetPostEmpresaBindingModel {
                            Tipo = tipo
                        });
                        result = await service.PostEmpresaBindingModel(model, user.CreateInstanceOf <ProfileMongoModel>());
                    }
                });
            });

            "Quando novamente solicitado obter todas as empresas"
            .x(async() => {
                var model = new PaginatedRequestCommand {
                    Page = 1, Take = 1000, Type = EnumUtility.GetEnumText(GetTypes.Paged)
                };
                listResult = await service.GetAll <ListaEmpresaMongoModel>(container, model);
            });

            "Então a quantidade de empresas deve ser {6}"
            .x(() => {
                Assert.Equal(listResult.Items.Count(), quantidadeEsperada);
            });
        }
コード例 #13
0
 // GET /api/cars
 public PaginatedDto <Car> Get(PaginatedRequestCommand cmd)
 {
     return(_carsCtx.GetAll(cmd.Page, cmd.Take).ToPaginatedDto());
 }
コード例 #14
0
        public virtual IHttpActionResult Get(PaginatedRequestCommand cmd)
        {
            cmd.FilterInternalDictionary = new Dictionary <string, object>();

            this.ListSelecting(cmd);

            if (this.ControllerContext.ControllerDescriptor != null)
            {
                this._tracer.Info(this.Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, string.Format("Começando Get {0}", cmd.Type));
            }

            var attr = typeof(TModel).GetCustomAttributes(true).OfType <DataEntityAttribute>().FirstOrDefault();

            if (cmd.Type.Equals(AInBox.Astove.Core.Enums.EnumUtility.GetEnumText(GetTypes.InsertModel), StringComparison.CurrentCultureIgnoreCase))
            {
                try
                {
                    TRequestModel requestModel = new TRequestModel();
                    BaseEntity.SetDropDownOptions <TRequestModel, IBindingModel>(requestModel, this.Container);

                    this.ListSelected(requestModel);

                    return(Ok(requestModel));
                }
                catch (Exception ex)
                {
                    if (this.ControllerContext.ControllerDescriptor != null)
                    {
                        this._tracer.Info(Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, "Tipo da exceção {0} {1}", ex.GetType(), ex.InnerException.GetType());
                    }

                    if (ex is ReflectionTypeLoadException || (ex.InnerException != null && ex.InnerException is ReflectionTypeLoadException))
                    {
                        ReflectionTypeLoadException typeLoadException = null;
                        if (ex.InnerException != null && ex.InnerException is ReflectionTypeLoadException)
                        {
                            typeLoadException = ex.InnerException as ReflectionTypeLoadException;
                        }
                        else
                        {
                            typeLoadException = ex as ReflectionTypeLoadException;
                        }

                        var loaderExceptins = typeLoadException.LoaderExceptions;
                        foreach (var tlex in loaderExceptins)
                        {
                            this._tracer.Error(Request, string.Format("{0} {1}", this.ControllerContext.ControllerDescriptor.ControllerType.FullName, tlex.GetType().FullName), "Erro: {0} {1}", new[] { tlex.Message, tlex.Source });
                        }
                    }
                    else
                    {
                        this._tracer.Debug(Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, ex.InnerException);
                    }

                    //return InternalServerError(base.ErrorMessage(ex));
                    return(InternalServerError(ex));
                }
            }
            else if (cmd.Type.Equals(AInBox.Astove.Core.Enums.EnumUtility.GetEnumText(GetTypes.UpdateModel), StringComparison.CurrentCultureIgnoreCase))
            {
                try
                {
                    string[] includeProperties = null;
                    if (attr != null)
                    {
                        includeProperties = attr.Include;
                    }

                    TEntity entity = this.Service.GetSingle(cmd.EntityId, includeProperties);
                    if (entity == null)
                    {
                        NotFound();
                    }
                    //return Request.CreateErrorResponse(HttpStatusCode.NotFound, string.Format("{0} não encontrado(a)", typeof(TEntity).Name));

                    TUpdateRequestModel model = entity.ToModel <TUpdateRequestModel, IModel>(this.Container, false, 0);

                    this.ListSelected(model);

                    return(Ok(model));
                }
                catch (Exception ex)
                {
                    return(InternalServerError(ex));
                }
            }
            else if (cmd.Type.Equals(AInBox.Astove.Core.Enums.EnumUtility.GetEnumText(GetTypes.PagedGrid), StringComparison.CurrentCultureIgnoreCase))
            {
                if (this.ControllerContext.ControllerDescriptor != null)
                {
                    this._tracer.Info(this.Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, string.Format("Começando Get ", cmd.Type));
                }

                try
                {
                    var list = this.Service.GetEntities(this.Container, cmd, typeof(TModel), cmd.OrdersBy, cmd.Directions, (attr != null) ? attr.Include : null);

                    var paginatedModel = list.ToPaginatedModel <TModel>(null, null);
                    SetViews(paginatedModel.Items);

                    paginatedModel.Condition         = new Condition();
                    paginatedModel.ColumnDefinitions = ColumnFactory.GenerateColumnDefinitions <TModel>(ActionEnum.List).ToArray();

                    this.ListSelected(paginatedModel);

                    return(Ok(paginatedModel));
                }
                catch (Exception ex)
                {
                    if (this.ControllerContext.ControllerDescriptor != null)
                    {
                        this._tracer.Info(Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, "Tipo da exceção {0} {1}", ex.GetType(), (ex.InnerException == null) ? null : ex.InnerException.GetType());
                    }

                    if (ex is ReflectionTypeLoadException || (ex.InnerException != null && ex.InnerException is ReflectionTypeLoadException))
                    {
                        ReflectionTypeLoadException typeLoadException = null;
                        if (ex.InnerException != null && ex.InnerException is ReflectionTypeLoadException)
                        {
                            typeLoadException = ex.InnerException as ReflectionTypeLoadException;
                        }
                        else
                        {
                            typeLoadException = ex as ReflectionTypeLoadException;
                        }

                        var loaderExceptins = typeLoadException.LoaderExceptions;
                        foreach (var tlex in loaderExceptins)
                        {
                            this._tracer.Error(Request, string.Format("{0} {1}", this.ControllerContext.ControllerDescriptor.ControllerType.FullName, tlex.GetType().FullName), "Erro: {0} {1}", new[] { tlex.Message, tlex.Source });
                        }
                    }
                    else if (this.ControllerContext.ControllerDescriptor != null)
                    {
                        this._tracer.Debug(Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, ex);
                    }

                    return(InternalServerError(ex));
                }
            }

            try
            {
                var entities = this.Service.GetEntities(this.Container, cmd, typeof(TModel), cmd.OrdersBy, cmd.Directions, (attr != null) ? attr.Include : null);
                var paged    = entities.ToPaginatedModel <TModel>(null, null);
                SetViews(paged.Items);

                paged.ColumnDefinitions = ColumnFactory.GenerateColumnDefinitions <TModel>(ActionEnum.List).ToArray();
                paged.Condition         = new Condition();

                this.ListSelected(paged);

                return(Ok(paged));
            }
            catch (Exception ex)
            {
                if (this.ControllerContext.ControllerDescriptor != null)
                {
                    this._tracer.Info(Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, "Tipo da exceção {0} {1}", ex.GetType(), ex.InnerException.GetType());
                }

                if (ex is ReflectionTypeLoadException || (ex.InnerException != null && ex.InnerException is ReflectionTypeLoadException))
                {
                    ReflectionTypeLoadException typeLoadException = null;
                    if (ex.InnerException != null && ex.InnerException is ReflectionTypeLoadException)
                    {
                        typeLoadException = ex.InnerException as ReflectionTypeLoadException;
                    }
                    else
                    {
                        typeLoadException = ex as ReflectionTypeLoadException;
                    }

                    var loaderExceptins = typeLoadException.LoaderExceptions;
                    foreach (var tlex in loaderExceptins)
                    {
                        this._tracer.Error(Request, string.Format("{0} {1}", this.ControllerContext.ControllerDescriptor.ControllerType.FullName, tlex.GetType().FullName), "Erro: {0} {1}", new[] { tlex.Message, tlex.Source });
                    }
                }
                else if (this.ControllerContext.ControllerDescriptor != null)
                {
                    this._tracer.Debug(Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, ex.InnerException);
                }

                return(InternalServerError(ex));
            }
        }
コード例 #15
0
 public virtual void ListSelecting(PaginatedRequestCommand command)
 {
 }
コード例 #16
0
        // GET /carsclient/cars
        public async Task <PaginatedDto <Car> > Get(PaginatedRequestCommand cmd)
        {
            var cars = await _carsClient.GetCars(cmd);

            return(cars);
        }
コード例 #17
0
        public async static Task <PaginatedMongoModel <TList> > GetAll <TList>(this IEntityService <Empresa> service, IComponentContext container, PaginatedRequestCommand model)
            where TList : class, IMongoModel, IDto, new()
        {
            var result = await service.MongoService.GetMongoListAsync <EmpresaClienteMongoModel, TList>(container, model);

            var paged = result.ToPaginatedModel <TList>();

            paged.ColumnDefinitions = ColumnFactory.GenerateColumnDefinitions <TList>(ActionEnum.List).ToArray();
            paged.Condition         = new Condition();

            return(paged);
        }
コード例 #18
0
        public void Post(int tipo, string nomeFantasia, string cnpj, string cep, int cidadeId, int estadoId, int idOuQuantidadeEsperada)
        {
            PostResultModel result = null;
            PaginatedMongoModel <ListaEmpresaMongoModel> listResult = null;
            BaseResultModel       getResult     = null;
            DropDownStringOptions optionsResult = null;

            "Quando solicitado adicionar empresa do tipo cliente {1}"
            .x(async() => {
                var user = await service.MongoService.GetMongoObjectByParentId <PessoaMongoModel>(1);
                if (user == null)
                {
                    result = new PostResultModel {
                        IsValid = false, StatusCode = 404, Message = "Profile não encontrado"
                    };
                }
                else
                {
                    var model = await service.GetPostEmpresaBindingModel(new GetPostEmpresaBindingModel {
                        Tipo = tipo
                    });
                    model.CNPJ         = cnpj;
                    model.NomeFantasia = nomeFantasia;
                    model.CEP          = cep;
                    model.EstadoId     = estadoId;
                    model.CidadeId     = cidadeId;

                    result = await service.PostEmpresaBindingModel(model, user.CreateInstanceOf <ProfileMongoModel>());
                }
            });

            "Então o result deve ser válido e conter as chaves do novo objeto criado com Id {6}"
            .x(() => {
                Assert.NotNull(result);
                Assert.Equal(result.IsValid, true);
                Assert.Equal(idOuQuantidadeEsperada, int.Parse(result.ParentId));
                Assert.NotNull(result.Id);
            });

            "Quando novamente solicitado obter todas as empresas"
            .x(async() => {
                var model = new PaginatedRequestCommand {
                    Page = 1, Take = 1000, Type = EnumUtility.GetEnumText(GetTypes.Paged)
                };
                listResult = await service.GetAll <ListaEmpresaMongoModel>(container, model);
            });

            "Então a quantidade de empresas deve ser {6}"
            .x(() => {
                Assert.Equal(listResult.Items.Count(), idOuQuantidadeEsperada);
            });

            "Quando for feita uma pesquisa por CNPJ {2}"
            .x(async() => {
                getResult = await service.GetEmpresasByDocumentoAsync(new GetEmpresasByDocumento {
                    CNPJ = cnpj
                });
            });

            "Então o nome fantasia deve ser {1}"
            .x(() => {
                Assert.Equal(getResult.IsValid, true);
                Assert.IsType <PostOrPutResultModel>(getResult);
                var empresaResult = (PostOrPutResultModel)getResult;
                Assert.IsType <PutEmpresaBindingModel>(empresaResult.BindingModel);
                var binding = (PutEmpresaBindingModel)empresaResult.BindingModel;
                Assert.Equal(binding.NomeFantasia, nomeFantasia);
            });

            "Quando for feita uma pesquisa por Id {2}"
            .x(async() => {
                getResult = await service.GetEmpresaByParentIdAsync(new GetBindingModel {
                    Id = result.ParentId
                });
            });

            "Então o nome fantasia deve ser {1}"
            .x(() => {
                Assert.Equal(getResult.IsValid, true);
                Assert.IsType <PostOrPutResultModel>(getResult);
                var empresaResult = (PostOrPutResultModel)getResult;
                Assert.IsType <PutEmpresaBindingModel>(empresaResult.BindingModel);
                var binding = (PutEmpresaBindingModel)empresaResult.BindingModel;
                Assert.Equal(binding.NomeFantasia, nomeFantasia);
            });

            "Quando for feita uma pesquisa por options por tipo de acesso {0}"
            .x(async() => {
                optionsResult = await service.GetEmpresasByTipoAcessoOptions(tipo);
            });

            "Então a lista de opções deve ter {6}-1 itens"
            .x(() => {
                Assert.Equal(optionsResult.Items.Count(), idOuQuantidadeEsperada - 1);
            });
        }