コード例 #1
0
        public async Task <IActionResult> PutUsers([FromRoute] int id, [FromBody] Users users)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

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

            _context.Entry(users).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UsersExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #2
0
        public async Task <IActionResult> PutCheckListRef([FromRoute] int id, [FromBody] CheckListRef checkListRef)
        {
            Blockage blockage = new Blockage();

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

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

            _context.Entry(checkListRef).State = EntityState.Modified;


            blockage.IdVehicule   = checkListRef.IdVehicule;
            blockage.DateBlockage = checkListRef.Date.Value.Date;
            blockage.IdCheckList  = checkListRef.IdCheckListRef;

            if (!(bool)checkListRef.Etat)
            {
                // _context.Entry(blockage).State = EntityState.Modified;
                var blockageUpdated = await _context.Blockage.FirstOrDefaultAsync(x => x.IdCheckList == blockage.IdCheckList);

                if (blockageUpdated != null)
                {
                    blockageUpdated.DateDeblockage = DateTime.Now.Date;
                    // blockageUpdated = blockage;
                    System.Diagnostics.Debug.WriteLine("Updated: " + blockageUpdated.IdCheckList + ", " + blockageUpdated.Id);
                }
            }
            else
            {
                if ((bool)checkListRef.Etat)
                {
                    _context.Blockage.Add(blockage);
                }
            }

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!CheckListRefExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #3
0
        public async Task <IActionResult> PutBlockage([FromRoute] int id, [FromBody] Blockage blockage)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

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

            _context.Entry(blockage).State = EntityState.Modified;

            if (blockage.ImageUrl.Contains("Upload"))
            {
                System.Diagnostics.Debug.WriteLine(blockage.ImageUrl);
            }
            else
            {
                if (blockage.ImageUrl != "")
                {
                    System.Diagnostics.Debug.WriteLine("Base64");
                    var imagePath = ConvertImage(blockage.ImageUrl);
                    blockage.ImageUrl = imagePath;
                }
                else
                {
                    blockage.ImageUrl = (string)null;
                }
            }


            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!BlockageExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #4
0
        public async Task <IActionResult> PutEngins([FromRoute] int id, [FromBody] Engins engins)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

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

            _context.Entry(engins).State = EntityState.Modified;

            if (engins.ImageEngin.Contains("Images"))
            {
                System.Diagnostics.Debug.WriteLine(engins.ImageEngin);
            }
            else
            {
                System.Diagnostics.Debug.WriteLine("Base64");
                var imagePath = ConvertImage(engins.ImageEngin);
                engins.ImageEngin = imagePath;
            }


            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!EnginsExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
コード例 #5
0
 public async Task Create(Conducteur conducteur)
 {
     _context.Conducteur.Add(conducteur);
     await _context.SaveChangesAsync();
 }
コード例 #6
0
ファイル: VehiculeRepo.cs プロジェクト: miidow93/iCheckAPI
 public async Task Create(Vehicule vehicule)
 {
     _context.Vehicule.Add(vehicule);
     await _context.SaveChangesAsync();
 }
コード例 #7
0
ファイル: SiteRepo.cs プロジェクト: miidow93/iCheckAPI
 public async Task Create(Site site)
 {
     _context.Site.Add(site);
     await _context.SaveChangesAsync();
 }