Example #1
0
        public async Task <CudResultDto> PutByKey(Guid id, [FromForm] OrderDto value)
        {
            var result = new CudResultDto
            {
                Success = false
            };

            try
            {
                var getOrderQuery = Repository.SearchFor(p => p.Key == id);
                var entity        = await Repository.ReadFirstAsync(getOrderQuery);

                Mapper.Map(value, entity);
                Repository.Update(entity);
                await Repository.SaveAsync();

                result.Id      = id.ToString();
                result.Success = true;
            }
            catch (DalValidationException ex)
            {
                result.Errors = ex.Errors.Select(p => p.Error).ToList();
            }
            return(result);
        }
        public virtual async Task <CudResultDto> Put(long id, [FromForm] TDto value)
        {
            var result = new CudResultDto
            {
                Success = false
            };

            try
            {
                var entity = await Repository.ReadByIdAsync(id);

                Mapper.Map(value, entity);
                Repository.Update(entity);
                await Repository.SaveAsync();

                result.Id      = id.ToString(CultureInfo.InvariantCulture);
                result.Success = true;
            }
            catch (DalValidationException ex)
            {
                result.Errors = ex.Errors.Select(p => p.Error).ToList();
            }

            return(result);
        }
        public async Task <CudResultDto> Post(Guid id, [FromForm] OrderEquipmentDto dto)
        {
            var result = new CudResultDto
            {
                Success = false
            };

            try
            {
                var query = Repository.SearchFor(p => p.Order.Key == id);
                var items = await Repository.ReadAsync(query);

                var deleteTasks = items.Select(p => Repository.DeleteAsync(p.Id)).ToArray();
                Task.WaitAll(deleteTasks);

                var findOrderQuery = OrderRepository.SearchFor(p => p.Key == id);
                var order          = await OrderRepository.ReadFirstAsync(findOrderQuery);

                if (dto != null && dto.EquipmentIds != null)
                {
                    foreach (var value in dto.EquipmentIds)
                    {
                        Repository.Create(new OrderAdditionalEquipmentItem
                        {
                            OrderId     = order.Id,
                            EquipmentId = value
                        });
                    }
                }
                await Repository.SaveAsync();


                result.Id      = id.ToString();
                result.Success = true;
            }
            catch (DalValidationException ex)
            {
                result.Errors = ex.Errors.Select(p => p.Error).ToList();
            }
            return(result);
        }
        public virtual async Task <CudResultDto> Delete(long id)
        {
            var result = new CudResultDto
            {
                Success = false
            };

            try
            {
                await Repository.DeleteAsync(id);

                await Repository.SaveAsync();

                result.Success = true;
            }
            catch (DalValidationException ex)
            {
                result.Errors = ex.Errors.Select(p => p.Error).ToList();
            }

            return(result);
        }
Example #5
0
        public override async Task <CudResultDto> Post([FromForm] OrderDto value)
        {
            var result = new CudResultDto
            {
                Success = false
            };

            try
            {
                var entity = Mapper.Map <Order>(value);
                Repository.Create(entity);
                await Repository.SaveAsync();

                result.Id      = entity.Key.ToString();
                result.Success = true;
            }
            catch (DalValidationException ex)
            {
                result.Errors = ex.Errors.Select(p => p.Error).ToList();
            }

            return(result);
        }
        public virtual async Task <CudResultDto> Post([FromForm] TDto value)
        {
            var result = new CudResultDto
            {
                Success = false
            };

            try
            {
                var entity = Mapper.Map <TEntity>(value);
                Repository.Create(entity);
                await Repository.SaveAsync();

                result.Id      = entity.Id.ToString(CultureInfo.InvariantCulture);
                result.Success = true;
            }
            catch (DalValidationException ex)
            {
                result.Errors = ex.Errors.Select(p => p.Error).ToList();
            }

            return(result);
        }