Example #1
0
        public Guid Add(FruitDto request)
        {
            var fruit    = (Fruit)request;
            var newFruit = base.Add(fruit);

            return(newFruit.Id);
        }
        public async Task FruitUpdate(FruitDto fruitDto)
        {
            string        sqlText = @"UPDATE Fruit 
                SET Price = @Price,Color=@Color,Name=@Name,StoreCode=@StoreCode
                WHERE Code=@Code";
            SqlConnection conn    = await ConnectContext.Current.GetOpenConnection();

            using (var tran = conn.BeginTransaction())
            {
                try
                {
                    await conn.ExecuteAsync(sqlText, fruitDto, tran);

                    tran.Commit();
                }
                catch (Exception ex)
                {
                    tran.Rollback();
                    throw ex;
                }
                finally
                {
                    tran.Dispose();
                }
            }
        }
Example #3
0
        public void Update(Guid id, FruitDto request)
        {
            var fruit = base.GetById(id);

            fruit.Name        = request.Name;
            fruit.Description = request.Description;
            fruit.PictureUrl  = request.PictureUrl;
            fruit.StockAmount = request.StockAmount;
            fruit.Price       = request.Price;

            base.Update(fruit);
        }
Example #4
0
        public void FruitUpdate(FruitDto fruitDto)
        {
            var filterBuild  = Builders <BsonDocument> .Filter;
            var filter       = filterBuild.Eq("Name", fruitDto.Name);
            var updaterBuild = Builders <BsonDocument> .Update;
            var updater      = updaterBuild.Set("Price", fruitDto.Price)
                               .Set("Color", fruitDto.Color)
                               .Set("Code", fruitDto.Code)
                               .Set("StoreCode", fruitDto.StoreCode);

            _collection.UpdateOne(filter, updater);
        }
        public async Task <IActionResult> Post([FromBody] FruitDto fruitDto)
        {
            try
            {
                if (fruitDto == null)
                {
                    return(this.BadRequestEx("fruitDto"));
                }
                await _fruitService.FruitAdd(new List <FruitDto>() { fruitDto });

                return(this.CreatedEx());
            }
            catch (Exception ex)
            {
                return(this.ErrorEx(ex.Message));
            }
        }
Example #6
0
        public async Task <IActionResult> Post([FromBody] FruitDto fruit)
        {
            using (var context = new ApplicationDbContext())
            {
                var newFruitEntityEntry = context.Fruits.Add(new Fruit
                {
                    Species = fruit.Species,
                    Color   = fruit.Color,
                    Country = fruit.Country
                });

                await context.SaveChangesAsync();

                // return Ok(new FruitDto(newFruitEntityEntry.Entity));
                return(Ok());
            }
        }
Example #7
0
        public IActionResult Post([FromBody] FruitDto dto)
        {
            try
            {
                var validRes = new FruitDtoValidation().Validate(dto);
                if (!validRes.IsValid)
                {
                    return(BadRequest(validRes.Errors));
                }

                var id = _fruitService.Add(dto);
                return(Created($"Game: {id}", id));
            }
            catch (Exception ex)
            {
                return(StatusCode(500, ex.Message));
            }
        }
Example #8
0
        public IActionResult Put(Guid id, [FromBody] FruitDto dto)
        {
            try
            {
                var validRes = new FruitDtoValidation().Validate(dto);
                if (!validRes.IsValid)
                {
                    return(BadRequest(validRes.Errors));
                }
                if (_fruitService.GetById(id) == null)
                {
                    return(BadRequest("Fruta não encontrado"));
                }

                _fruitService.Update(id, dto);
                return(Ok());
            }
            catch (Exception ex)
            {
                return(StatusCode(500, ex.Message));
            }
        }
Example #9
0
        public IActionResult Put(string name, [FromBody] FruitDto fruitDto)
        {
            try
            {
                if (fruitDto == null)
                {
                    return(this.BadRequestEx("fruitDto"));
                }

                var fruit = _fruitService.FruitQuery(name);
                if (fruit == null)
                {
                    return(this.NotFoundEx());
                }

                _fruitService.FruitUpdate(fruitDto);
                return(this.NoContentEx());
            }
            catch (Exception ex)
            {
                return(this.ErrorEx(ex.Message));
            }
        }
Example #10
0
        public IActionResult Post([FromBody] FruitDto fruitDto)
        {
            try
            {
                if (fruitDto == null)
                {
                    return(this.BadRequestEx("fruitDto"));
                }

                var fruitDtoBson = BsonDocument.Parse(JsonConvert.SerializeObject(fruitDto));
                if (fruitDtoBson == null)
                {
                    return(this.BadRequestEx("fruitDto"));
                }

                _fruitService.FruitAdd(fruitDtoBson);
                return(this.CreatedEx());
            }
            catch (Exception ex)
            {
                return(this.ErrorEx(ex.Message));
            }
        }
        public async Task <IActionResult> Patch(string code, [FromBody] FruitDto fruitDto)
        {
            try
            {
                if (fruitDto == null)
                {
                    return(this.BadRequestEx("fruitDto"));
                }

                var fruit = _fruitService.FruitQuery(code);
                if (fruit == null)
                {
                    return(this.NotFoundEx());
                }

                await _fruitService.FruitUpdate(fruitDto);

                return(this.NoContentEx());
            }
            catch (Exception ex)
            {
                return(this.ErrorEx(ex.Message));
            }
        }
        public async Task <IActionResult> Put([FromBody] FruitDto fruitDto)
        {
            try
            {
                if (fruitDto == null)
                {
                    return(this.BadRequestEx("fruitDto"));
                }

                //var fruit = _fruitService.FruitQuery(name);
                //if (fruit == null)
                //{
                //    return this.NotFoundEx();
                //}

                await _fruitService.FruitUpdate(fruitDto);

                return(this.NoContentEx());
            }
            catch (Exception ex)
            {
                return(this.ErrorEx(ex.Message));
            }
        }