Q:

what can i use instead of `case of` to reduce the code?

fmap ( \eachSheet -> case (eachSheet ^. sProperties) of
  Just sheetProperties -> case (sheetProperties ^. sTitle) of
    Just sheets -> (sheetProperties ^. sSheetId)    
    Nothing -> Nothing
  Nothing -> Nothing ) listOfSheets

any better way to this then case matching 

A:

The particular pattern
     case f foo of
       Just bla -> case g bla of
          Just muh -> h muh
       Nothing -> Nothing

is chararacteristic of the Maybe monad. That instance is defined as
instance Monad Maybe where
  return = Just
  Nothing >>= _ = Nothing
  Just x >>= f = f x

So you can rewrite the above case construction to
    f foo >>= \bla -> g bla >>= \muh -> h muh

which can be made more readable by either using do syntax
    do
      bla <- f foo
      muh <- g bla
      h muh

or eta-reduction and the Kleisli-composition operator
     (f >=> g >=> h) foo

In your example, the latter is actually not possible because the innermost function doesn't use sheets but sheetProperties again, but do notation can still be used.

A:

What you here bascially show is the use of a Maybe monad, so we can write it like:
fmap (\s -> (s ^. sProperties) >>= \sheetProperties -> (sheetProperties ^. sTitle) >> (sheetProperties ^. sSheetId)) listOfSheets

Since a Maybe monad is defined as:

instance Monad Maybe where
    return = Just
    (>>=) Nothing _ = Nothing
    (>>=) (Just x) f = f x

Or we can write it in do notation, although that is basically the same:
fmap f listOfSheets
    where f eachSheet = do
        sheetProperties <- eachSheet ^. sProperties
        sheets <- sheetProperties ^. sTitle
        sheetProperties ^. sSheetId

