public async Task <IHttpActionResult> Putdestinations(long id, destinations destinations)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != destinations.id)
            {
                return(BadRequest());
            }

            db.Entry(destinations).State = EntityState.Modified;

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!destinationsExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }
            Logger.CreateLog(HttpContext.Current.Request.Url.PathAndQuery, HttpMethod.Put.Method, null);
            return(StatusCode(HttpStatusCode.NoContent));
        }
        public async Task <IHttpActionResult> Getdestinations(long id)
        {
            destinations destinations = await db.destinations.FindAsync(id);

            if (destinations == null)
            {
                return(NotFound());
            }
            Logger.CreateLog(HttpContext.Current.Request.Url.PathAndQuery, HttpMethod.Get.Method, null);
            return(Ok(destinations));
        }
        public async Task <IHttpActionResult> Postdestinations(destinations destinations)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            db.destinations.Add(destinations);
            await db.SaveChangesAsync();

            Logger.CreateLog(HttpContext.Current.Request.Url.PathAndQuery, HttpMethod.Post.Method, null);
            return(CreatedAtRoute("DefaultApi", new { id = destinations.id }, destinations));
        }
        public async Task <IHttpActionResult> Deletedestinations(long id)
        {
            destinations destinations = await db.destinations.FindAsync(id);

            if (destinations == null)
            {
                return(NotFound());
            }

            db.destinations.Remove(destinations);
            await db.SaveChangesAsync();

            Logger.CreateLog(HttpContext.Current.Request.Url.PathAndQuery, HttpMethod.Delete.Method, null);
            return(Ok(destinations));
        }
Esempio n. 5
0
        public async Task <IHttpActionResult> Postboxes(OrderModel order)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            db.Database.BeginTransaction();



            var destination = new destinations()
            {
                country           = order.Country,
                city              = order.City,
                post_code         = order.Post_code,
                street            = order.Street,
                house_number      = order.House_number,
                apartment_number  = order.Apartment_number,
                recipient_name    = order.Recipient_name,
                recipient_surname = order.Recipient_surname
            };

            db.destinations.Add(destination);
            var addDestinationResult = await db.SaveChangesAsync();

            if (addDestinationResult <= 0)
            {
                db.Database.CurrentTransaction.Rollback();
                return(BadRequest());
            }

            var pack = new boxes()
            {
                customer_key        = order.CustomerKey,
                pack_number         = order.PackNumber,
                dimensions          = order.Dimensions,
                weight              = order.Weight,
                to_pay              = order.ToPay,
                delivery_status     = 1,
                destination_id      = destination.id,
                current_check_point = order.CheckPointID
            };

            db.boxes.Add(pack);
            var addPackResult = await db.SaveChangesAsync();

            if (addPackResult <= 0)
            {
                db.Database.CurrentTransaction.Rollback();
                return(BadRequest());
            }

            var courier = new couriers()
            {
                courier_id   = 1,
                pack_id      = pack.id,
                is_available = true
            };

            db.couriers.Add(courier);
            var addCourierRangeResult = await db.SaveChangesAsync();

            if (addCourierRangeResult <= 0)
            {
                db.Database.CurrentTransaction.Rollback();
                return(BadRequest());
            }

            db.Database.CurrentTransaction.Commit();

            Logger.CreateLog(HttpContext.Current.Request.Url.PathAndQuery, HttpMethod.Post.Method, null);
            return(Ok());
        }