public IActionResult Create([FromBody] OperationalRoleType newmodel)
        {
            if (ModelState.IsValid)
            {
                _context.OperationalRoleType.Add(newmodel);
                _context.SaveChanges();

                return(CreatedAtRoute("GetOperationalRole", new { id = newmodel.OperationalRoleTypeID }, newmodel));
            }
            else
            {
                return(BadRequest());
            }
        }
        public IActionResult UpdateEntry([FromBody] OperationalRoleType objupd)
        {
            var targetObject = _context.OperationalRoleType.FirstOrDefault(t => t.OperationalRoleTypeID == objupd.OperationalRoleTypeID);

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

            _context.Entry(targetObject).CurrentValues.SetValues(objupd);
            ReturnData ret;

            ret = _context.SaveData();

            if (ret.Message == "Success")
            {
                return(Ok());
            }

            return(NotFound(ret));
        }
        public void OperationalRoleType()
        {
            IQueryable <OperationalRoleType> OperationalRoleTypeCollection = Enumerable.Empty <OperationalRoleType>().AsQueryable();
            OperationalRoleType ct = new OperationalRoleType {
                OperationalRoleTypeID = 1, OperationalRoleName = "Test ORT"
            };

            Mock <IOperationalRoleTypeRepository> OperationalRoleTypeService = new Mock <IOperationalRoleTypeRepository>();

            object obj = new object();

            try
            {
                OperationalRoleTypeService.Setup(x => x.GetAll()).Returns(OperationalRoleTypeCollection);
                OperationalRoleTypeService.Setup(x => x.Get(It.IsAny <int>())).Returns(ct);
                OperationalRoleTypeService.Setup(x => x.Add(It.IsAny <OperationalRoleType>())).Returns(ct);
                OperationalRoleTypeService.Setup(x => x.Delete(It.IsAny <OperationalRoleType>())).Verifiable();
                OperationalRoleTypeService.Setup(x => x.Update(It.IsAny <OperationalRoleType>(), It.IsAny <object>())).Returns(ct);

                var OperationalRoleTypeObject = OperationalRoleTypeService.Object;
                var p1 = OperationalRoleTypeObject.GetAll();
                var p2 = OperationalRoleTypeObject.Get(1);
                var p3 = OperationalRoleTypeObject.Update(ct, obj);
                var p4 = OperationalRoleTypeObject.Add(ct);
                OperationalRoleTypeObject.Delete(ct);

                Assert.IsAssignableFrom <IQueryable <OperationalRoleType> >(p1);
                Assert.IsAssignableFrom <OperationalRoleType>(p2);
                Assert.Equal("Test ORT", p2.OperationalRoleName);
                Assert.Equal("Test ORT", p3.OperationalRoleName);

                OperationalRoleTypeService.VerifyAll();

                OperationalRoleTypeObject.Dispose();
            }
            finally
            {
                OperationalRoleTypeService = null;
            }
        }
Esempio n. 4
0
        public IActionResult Update([FromBody] OperationalRoleType editentry)
        {
            var result = _repository.Update(editentry, editentry.OperationalRoleTypeID);

            return(Helper.CheckResult(result));
        }
Esempio n. 5
0
        public IActionResult Create([FromBody] OperationalRoleType newentry)
        {
            var result = _repository.Add(newentry);

            return(CreatedAtRoute("GetOperationalRoleType", new { id = newentry.OperationalRoleTypeID }, newentry));
        }