public async Task <IActionResult> AddRoleFunctionMapping([FromBody] RoleFunctionMappingRequest model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var RoleFunctionMappingId = await roleFunctionMappingRepository.AddRoleFunctionMapping(model);

                    if (RoleFunctionMappingId > 0)
                    {
                        return(Ok(RoleFunctionMappingId));
                    }
                    else
                    {
                        return(NotFound());
                    }
                }
                catch (Exception)
                {
                    return(BadRequest());
                }
            }

            return(BadRequest());
        }
 public async Task UpdateRoleFunctionMapping(RoleFunctionMappingRequest RoleFunctionMapping)
 {
     if (_db != null)
     {
         var existingMapping = _db.RoleFunctionMapping.Where(s => s.Id == RoleFunctionMapping.Id).FirstOrDefault <Models.RoleFunctionMapping>();
         if (existingMapping != null)
         {
             existingMapping.RoleId     = RoleFunctionMapping.RoleId;
             existingMapping.FunctionId = RoleFunctionMapping.FunctionId;
             existingMapping.StatusId   = RoleFunctionMapping.StatusId;
         }
         await _db.SaveChangesAsync();
     }
 }
        public async Task <int> AddRoleFunctionMapping(RoleFunctionMappingRequest Role)
        {
            if (_db != null)
            {
                await _db.RoleFunctionMapping.AddAsync(new RoleFunctionMapping()
                {
                    RoleId     = Role.RoleId,
                    FunctionId = Role.FunctionId,
                    StatusId   = Role.StatusId
                });

                await _db.SaveChangesAsync();

                return(1);
            }

            return(0);
        }
        public async Task <IActionResult> UpdateRoleFunctionMapping(RoleFunctionMappingRequest model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    await roleFunctionMappingRepository.UpdateRoleFunctionMapping(model);

                    return(Ok());
                }
                catch (Exception ex)
                {
                    if (ex.GetType().FullName == "Microsoft.EntityFrameworkCore.DbUpdateConcurrencyException")
                    {
                        return(NotFound());
                    }

                    return(BadRequest());
                }
            }

            return(BadRequest());
        }