public async Task<ActionResult<RollbackData>> PostRollbackData(RollbackData data)
        {
            try
            {
                var result = _handler.Add(data);

                if (result)
                {
                    await _context.SaveChangesAsync();
                    return StatusCode(StatusCodes.Status201Created,
                        string.Format("Succesfully added RollbackData, Result -> {0}", result));
                }
                else
                {
                    return StatusCode(StatusCodes.Status409Conflict, string.Format("Unable to add RollbackData, Result -> {0}", result));
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw e;
            }

            //_context.RollbackDatas.Add(rollbackData);
            //await _context.SaveChangesAsync();

            //return CreatedAtAction("GetRollbackData", new { id = rollbackData.Id }, rollbackData);
        }
Example #2
0
        static List <RollbackData> getContainsRollbackPropertieTiles(List <XmlNode> tiles)
        {
            List <RollbackData> list = new List <RollbackData>();

            for (int i = 0; i < tiles.Count; i++)
            {
                XmlNodeList nodeList = tiles[i].ChildNodes;
                for (int k = 0; k < nodeList.Count; k++)
                {
                    if (nodeList[k].Name == "properties")
                    {
                        XmlNodeList properties = nodeList[k].ChildNodes;
                        for (int n = 0; n < properties.Count; n++)
                        {
                            if (properties[n].Name == "property")
                            {
                                RollbackData roll = new RollbackData();
                                roll.gid      = int.Parse(tiles[i].Attributes["id"].Value);
                                roll.rollback = int.Parse(properties[n].Attributes["value"].Value);
                                list.Add(roll);
                            }
                        }
                    }
                }
            }
            return(list);
        }
        public async Task<IActionResult> PutRollbackData(RollbackData data)
        {
            try
            {
                var result = _handler.Update(data);

                if (result)
                {
                    await _context.SaveChangesAsync();
                    return StatusCode(StatusCodes.Status202Accepted,
                        string.Format("Succesfully updated RollbackData, Result -> {0}", result));
                }
                else
                {
                    return StatusCode(StatusCodes.Status409Conflict, string.Format("Unable to update RollbackData, Result -> {0}", result));
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }

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

            //_context.Entry(rollbackData).State = EntityState.Modified;

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

            //return NoContent();
        }
        public async Task<ActionResult<IEnumerable<RollbackData>>> GetRollbackDatas(RollbackData data)
        {
            try
            {
                var results = await Task.Run(async () => _handler.FindMultiple(data));

                return Ok(results);
            }
            catch (Exception e)
            {
                if (e.Message.Contains("Found no results"))
                {
                    return NoContent();
                }
                else
                {
                    Console.WriteLine(e);
                    throw e;
                }
            }

            //return await _context.RollbackDatas.ToListAsync();
        }
 public ProcessingDataRollback(RollbackData handingRollback)
 {
     _handingRollback = handingRollback;
 }