{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StrictData #-}

-- |
-- Module      : Groups
-- Description : Queries about and updates to groups
-- Copyright   : (c) Rob Stewart, Heriot-Watt University, 2019
-- License     : BSD3
-- Maintainer  : robstewart57@gmail.com
-- Stability   : stable
module GitLab.API.Groups
  ( -- * List groups
    groups,

    -- * List a group’s subgroups
    subGroups,

    -- * List a group’s descendant groups
    descendantGroups,

    -- * List a group’s projects
    groupProjects,

    -- * List a group’s shared projects
    groupSharedProjects,

    -- * Details of a group
    group,

    -- * New group
    newGroup,

    -- * New Subgroup
    newSubGroup,

    -- * Update group
    updateGroup,

    -- * Remove group
    removeGroup,

    -- * Search for group
    searchGroup,

    -- * Group attributes
    ListGroupsAttrs (..),
    GroupOrderBy (..),
    GroupProjectAttrs (..),
    GroupProjectOrderBy (..),
    GroupAttrs (..),
    BranchProtection (..),
    defaultGroupFilters,
    defaultListGroupsFilters,
    defaultGroupProjectFilters,
  )
where

import qualified Data.ByteString.Lazy as BSL
import Data.Either
import Data.Maybe
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import GitLab.Types
import GitLab.WebRequests.GitLabWebCalls
import Network.HTTP.Client

-- | Get a list of visible groups for the authenticated user.
groups :: ListGroupsAttrs -> GitLab [Group]
groups :: ListGroupsAttrs -> GitLab [Group]
groups ListGroupsAttrs
attrs =
  [Group] -> Either (Response ByteString) [Group] -> [Group]
forall b a. b -> Either a b -> b
fromRight ([Char] -> [Group]
forall a. HasCallStack => [Char] -> a
error [Char]
"groups error")
    (Either (Response ByteString) [Group] -> [Group])
-> GitLabT IO (Either (Response ByteString) [Group])
-> GitLab [Group]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> [GitLabParam]
-> GitLabT IO (Either (Response ByteString) [Group])
forall a.
FromJSON a =>
Text -> [GitLabParam] -> GitLab (Either (Response ByteString) [a])
gitlabGetMany Text
"/groups" (ListGroupsAttrs -> [GitLabParam]
listGroupsAttrs ListGroupsAttrs
attrs)

-- | Get a list of visible direct subgroups in this group.
subGroups :: Group -> ListGroupsAttrs -> GitLab [Group]
subGroups :: Group -> ListGroupsAttrs -> GitLab [Group]
subGroups Group
parentGrp ListGroupsAttrs
attrs =
  [Group] -> Either (Response ByteString) [Group] -> [Group]
forall b a. b -> Either a b -> b
fromRight ([Char] -> [Group]
forall a. HasCallStack => [Char] -> a
error [Char]
"subGroups error")
    (Either (Response ByteString) [Group] -> [Group])
-> GitLabT IO (Either (Response ByteString) [Group])
-> GitLab [Group]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> [GitLabParam]
-> GitLabT IO (Either (Response ByteString) [Group])
forall a.
FromJSON a =>
Text -> [GitLabParam] -> GitLab (Either (Response ByteString) [a])
gitlabGetMany
      ( Text
"/groups/"
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show (Group -> Int
group_id Group
parentGrp))
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/subgroups"
      )
      (ListGroupsAttrs -> [GitLabParam]
listGroupsAttrs ListGroupsAttrs
attrs)

-- | Get a list of visible descendant groups of this group.
descendantGroups :: Group -> ListGroupsAttrs -> GitLab [Group]
descendantGroups :: Group -> ListGroupsAttrs -> GitLab [Group]
descendantGroups Group
parentGrp ListGroupsAttrs
attrs =
  [Group] -> Either (Response ByteString) [Group] -> [Group]
forall b a. b -> Either a b -> b
fromRight ([Char] -> [Group]
forall a. HasCallStack => [Char] -> a
error [Char]
"subGroups error")
    (Either (Response ByteString) [Group] -> [Group])
-> GitLabT IO (Either (Response ByteString) [Group])
-> GitLab [Group]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> [GitLabParam]
-> GitLabT IO (Either (Response ByteString) [Group])
forall a.
FromJSON a =>
Text -> [GitLabParam] -> GitLab (Either (Response ByteString) [a])
gitlabGetMany
      ( Text
"/groups/"
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show (Group -> Int
group_id Group
parentGrp))
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/descendant_groups"
      )
      (ListGroupsAttrs -> [GitLabParam]
listGroupsAttrs ListGroupsAttrs
attrs)

-- | Get a list of projects in this group.
groupProjects :: Group -> GroupProjectAttrs -> GitLab [Project]
groupProjects :: Group -> GroupProjectAttrs -> GitLab [Project]
groupProjects Group
parentGrp GroupProjectAttrs
attrs =
  [Project] -> Either (Response ByteString) [Project] -> [Project]
forall b a. b -> Either a b -> b
fromRight ([Char] -> [Project]
forall a. HasCallStack => [Char] -> a
error [Char]
"groupProjects error")
    (Either (Response ByteString) [Project] -> [Project])
-> GitLabT IO (Either (Response ByteString) [Project])
-> GitLab [Project]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> [GitLabParam]
-> GitLabT IO (Either (Response ByteString) [Project])
forall a.
FromJSON a =>
Text -> [GitLabParam] -> GitLab (Either (Response ByteString) [a])
gitlabGetMany
      ( Text
"/groups/"
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show (Group -> Int
group_id Group
parentGrp))
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/projects"
      )
      (GroupProjectAttrs -> [GitLabParam]
groupProjectAttrs GroupProjectAttrs
attrs)

-- | Get a list of projects in this group.
groupSharedProjects :: Group -> GroupProjectAttrs -> GitLab [Project]
groupSharedProjects :: Group -> GroupProjectAttrs -> GitLab [Project]
groupSharedProjects Group
parentGrp GroupProjectAttrs
attrs =
  [Project] -> Either (Response ByteString) [Project] -> [Project]
forall b a. b -> Either a b -> b
fromRight ([Char] -> [Project]
forall a. HasCallStack => [Char] -> a
error [Char]
"groupSharedProjects error")
    (Either (Response ByteString) [Project] -> [Project])
-> GitLabT IO (Either (Response ByteString) [Project])
-> GitLab [Project]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> [GitLabParam]
-> GitLabT IO (Either (Response ByteString) [Project])
forall a.
FromJSON a =>
Text -> [GitLabParam] -> GitLab (Either (Response ByteString) [a])
gitlabGetMany
      ( Text
"/groups/"
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show (Group -> Int
group_id Group
parentGrp))
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/projects/shared"
      )
      (GroupProjectAttrs -> [GitLabParam]
groupProjectAttrs GroupProjectAttrs
attrs)

-- | Get all details of a group.
group ::
  -- | group ID
  Int ->
  GitLab (Either (Response BSL.ByteString) (Maybe Group))
group :: Int -> GitLab (Either (Response ByteString) (Maybe Group))
group Int
pId = do
  Text
-> [GitLabParam]
-> GitLab (Either (Response ByteString) (Maybe Group))
forall a.
FromJSON a =>
Text
-> [GitLabParam] -> GitLab (Either (Response ByteString) (Maybe a))
gitlabGetOne Text
urlPath []
  where
    urlPath :: Text
urlPath =
      Text
"/groups/"
        Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
pId)

-- | Creates a new project group (TODO include attributes).
newGroup ::
  -- | group name
  Text ->
  -- | group path
  Text ->
  -- | group attributes
  GroupAttrs ->
  GitLab (Either (Response BSL.ByteString) (Maybe Group))
newGroup :: Text
-> Text
-> GroupAttrs
-> GitLab (Either (Response ByteString) (Maybe Group))
newGroup Text
nameTxt Text
pathTxt GroupAttrs
attrs = do
  Text
-> [GitLabParam]
-> GitLab (Either (Response ByteString) (Maybe Group))
forall a.
FromJSON a =>
Text
-> [GitLabParam] -> GitLab (Either (Response ByteString) (Maybe a))
gitlabPost
    Text
newProjectAddr
    ([(ByteString
"name", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Text -> ByteString
T.encodeUtf8 Text
nameTxt)), (ByteString
"path", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Text -> ByteString
T.encodeUtf8 Text
pathTxt))] [GitLabParam] -> [GitLabParam] -> [GitLabParam]
forall a. Semigroup a => a -> a -> a
<> GroupAttrs -> [GitLabParam]
groupAttrs GroupAttrs
attrs)
  where
    newProjectAddr :: Text
    newProjectAddr :: Text
newProjectAddr =
      Text
"/groups"

-- | Creates a new project group.
newSubGroup ::
  -- | group name
  Text ->
  -- | group path
  Text ->
  -- | parent group ID
  Int ->
  -- | group attributes
  GroupAttrs ->
  GitLab (Either (Response BSL.ByteString) (Maybe Group))
newSubGroup :: Text
-> Text
-> Int
-> GroupAttrs
-> GitLab (Either (Response ByteString) (Maybe Group))
newSubGroup Text
nameTxt Text
pathTxt Int
parentId GroupAttrs
attrs = do
  Text
-> [GitLabParam]
-> GitLab (Either (Response ByteString) (Maybe Group))
forall a.
FromJSON a =>
Text
-> [GitLabParam] -> GitLab (Either (Response ByteString) (Maybe a))
gitlabPost
    Text
newProjectAddr
    ([(ByteString
"name", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Text -> ByteString
T.encodeUtf8 Text
nameTxt)), (ByteString
"path", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Text -> ByteString
T.encodeUtf8 Text
pathTxt)), (ByteString
"parent_id", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Text -> ByteString
T.encodeUtf8 ([Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
parentId))))] [GitLabParam] -> [GitLabParam] -> [GitLabParam]
forall a. Semigroup a => a -> a -> a
<> GroupAttrs -> [GitLabParam]
groupAttrs GroupAttrs
attrs)
  where
    newProjectAddr :: Text
    newProjectAddr :: Text
newProjectAddr =
      Text
"/groups"

-- | Updates the project group. Only available to group owners and
-- administrators.
updateGroup ::
  -- | The ID of the group.
  Int ->
  -- | Group attributes
  GroupAttrs ->
  GitLab (Either (Response BSL.ByteString) (Maybe Group))
updateGroup :: Int
-> GroupAttrs
-> GitLab (Either (Response ByteString) (Maybe Group))
updateGroup Int
groupId GroupAttrs
attrs =
  Text
-> [GitLabParam]
-> GitLab (Either (Response ByteString) (Maybe Group))
forall a.
FromJSON a =>
Text
-> [GitLabParam] -> GitLab (Either (Response ByteString) (Maybe a))
gitlabPut
    Text
newProjectAddr
    (GroupAttrs -> [GitLabParam]
groupAttrs GroupAttrs
attrs)
  where
    newProjectAddr :: Text
    newProjectAddr :: Text
newProjectAddr =
      Text
"/groups/"
        Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
groupId)

-- | Only available to group owners and administrators.
removeGroup ::
  -- | The ID of the group.
  Int ->
  GitLab (Either (Response BSL.ByteString) (Maybe ()))
removeGroup :: Int -> GitLab (Either (Response ByteString) (Maybe ()))
removeGroup Int
grpId =
  Text
-> [GitLabParam]
-> GitLab (Either (Response ByteString) (Maybe ()))
forall a.
FromJSON a =>
Text
-> [GitLabParam] -> GitLab (Either (Response ByteString) (Maybe a))
gitlabDelete Text
groupAddr []
  where
    groupAddr :: Text
    groupAddr :: Text
groupAddr =
      Text
"/groups/"
        Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
grpId)

-- | Get all groups that match your string in their name or path.
searchGroup ::
  -- | String or path to search for.
  Text ->
  GitLab [Group]
searchGroup :: Text -> GitLab [Group]
searchGroup Text
searchTxt =
  [Group] -> Either (Response ByteString) [Group] -> [Group]
forall b a. b -> Either a b -> b
fromRight ([Char] -> [Group]
forall a. HasCallStack => [Char] -> a
error [Char]
"searchGroups error")
    (Either (Response ByteString) [Group] -> [Group])
-> GitLabT IO (Either (Response ByteString) [Group])
-> GitLab [Group]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> [GitLabParam]
-> GitLabT IO (Either (Response ByteString) [Group])
forall a.
FromJSON a =>
Text -> [GitLabParam] -> GitLab (Either (Response ByteString) [a])
gitlabGetMany Text
"/groups" [(ByteString
"search", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Text -> ByteString
T.encodeUtf8 Text
searchTxt))]

-- | Attributes related to a group
data GroupProjectAttrs = GroupProjectAttrs
  { GroupProjectAttrs -> Maybe Int
groupProjectFilter_id :: Maybe Int,
    GroupProjectAttrs -> Maybe Bool
groupProjectFilter_archived :: Maybe Bool,
    GroupProjectAttrs -> Maybe Visibility
groupProjectFilter_visibility :: Maybe Visibility,
    GroupProjectAttrs -> Maybe GroupProjectOrderBy
groupProjectFilter_order_by :: Maybe GroupProjectOrderBy,
    GroupProjectAttrs -> Maybe SortBy
groupProjectFilter_sort :: Maybe SortBy,
    GroupProjectAttrs -> Maybe Text
groupProjectFilter_search :: Maybe Text,
    GroupProjectAttrs -> Maybe Bool
groupProjectFilter_simple :: Maybe Bool,
    GroupProjectAttrs -> Maybe Bool
groupProjectFilter_owned :: Maybe Bool,
    GroupProjectAttrs -> Maybe Bool
groupProjectFilter_starred :: Maybe Bool,
    GroupProjectAttrs -> Maybe Bool
groupProjectFilter_with_issues_enabled :: Maybe Bool,
    GroupProjectAttrs -> Maybe Bool
groupProjectFilter_with_merge_requests_enabled :: Maybe Bool,
    GroupProjectAttrs -> Maybe Bool
groupProjectFilter_with_shared :: Maybe Bool,
    GroupProjectAttrs -> Maybe Bool
groupProjectFilter_include_subgroups :: Maybe Bool,
    GroupProjectAttrs -> Maybe AccessLevel
groupProjectFilter_min_access_level :: Maybe AccessLevel,
    GroupProjectAttrs -> Maybe Bool
groupProjectFilter_with_custom_attributes :: Maybe Bool,
    GroupProjectAttrs -> Maybe Bool
groupProjectFilter_with_security_reports :: Maybe Bool
  }

-- | No group filters applied, thereby returning all groups.
defaultGroupProjectFilters :: GroupProjectAttrs
defaultGroupProjectFilters :: GroupProjectAttrs
defaultGroupProjectFilters =
  Maybe Int
-> Maybe Bool
-> Maybe Visibility
-> Maybe GroupProjectOrderBy
-> Maybe SortBy
-> Maybe Text
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe AccessLevel
-> Maybe Bool
-> Maybe Bool
-> GroupProjectAttrs
GroupProjectAttrs Maybe Int
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Visibility
forall a. Maybe a
Nothing Maybe GroupProjectOrderBy
forall a. Maybe a
Nothing Maybe SortBy
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe AccessLevel
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing

-- | The order of group projects in search results.
data GroupProjectOrderBy
  = GroupProjectOrderId
  | GroupProjectOrderName
  | GroupProjectOrderPath
  | GroupProjectOrderCreatedAt
  | GroupProjectOrderUpdatedAt
  | GroupProjectOrderSimilarity
  | GroupProjectOrderLastActivityAt

instance Show GroupProjectOrderBy where
  show :: GroupProjectOrderBy -> [Char]
show GroupProjectOrderBy
GroupProjectOrderName = [Char]
"id"
  show GroupProjectOrderBy
GroupProjectOrderPath = [Char]
"name"
  show GroupProjectOrderBy
GroupProjectOrderId = [Char]
"path"
  show GroupProjectOrderBy
GroupProjectOrderCreatedAt = [Char]
"created_at"
  show GroupProjectOrderBy
GroupProjectOrderUpdatedAt = [Char]
"updated_at"
  show GroupProjectOrderBy
GroupProjectOrderSimilarity = [Char]
"similarity"
  show GroupProjectOrderBy
GroupProjectOrderLastActivityAt = [Char]
"last_activity_at"

groupProjectAttrs :: GroupProjectAttrs -> [GitLabParam]
groupProjectAttrs :: GroupProjectAttrs -> [GitLabParam]
groupProjectAttrs GroupProjectAttrs
filters =
  [Maybe GitLabParam] -> [GitLabParam]
forall a. [Maybe a] -> [a]
catMaybes
    [ (\Int
i -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"id", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i)))) (Int -> Maybe GitLabParam) -> Maybe Int -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Int
groupProjectFilter_id GroupProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"archived", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Bool
groupProjectFilter_archived GroupProjectAttrs
filters,
      (\Text
v -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"visibility", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (Text -> [Char]
forall a. Show a => a -> [Char]
show Text
v)))) (Text -> Maybe GitLabParam) -> Maybe Text -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Text
groupProjectFilter_search GroupProjectAttrs
filters,
      (\GroupProjectOrderBy
grpOrder -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"order_by", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (GroupProjectOrderBy -> [Char]
forall a. Show a => a -> [Char]
show GroupProjectOrderBy
grpOrder)))) (GroupProjectOrderBy -> Maybe GitLabParam)
-> Maybe GroupProjectOrderBy -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe GroupProjectOrderBy
groupProjectFilter_order_by GroupProjectAttrs
filters,
      (\SortBy
sortBy -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"sort", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (SortBy -> [Char]
forall a. Show a => a -> [Char]
show SortBy
sortBy)))) (SortBy -> Maybe GitLabParam) -> Maybe SortBy -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe SortBy
groupProjectFilter_sort GroupProjectAttrs
filters,
      (\Text
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"search", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (Text -> [Char]
forall a. Show a => a -> [Char]
show Text
x)))) (Text -> Maybe GitLabParam) -> Maybe Text -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Text
groupProjectFilter_search GroupProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"simple", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Bool
groupProjectFilter_simple GroupProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"owned", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Bool
groupProjectFilter_owned GroupProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"starred", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Bool
groupProjectFilter_starred GroupProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"with_issues_enabled", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Bool
groupProjectFilter_with_issues_enabled GroupProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"with_merge_requests_enabled", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Bool
groupProjectFilter_with_merge_requests_enabled GroupProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"with_shared", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Bool
groupProjectFilter_with_shared GroupProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"include_subgroups", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Bool
groupProjectFilter_include_subgroups GroupProjectAttrs
filters,
      (\AccessLevel
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"min_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (AccessLevel -> [Char]
forall a. Show a => a -> [Char]
show AccessLevel
x)))) (AccessLevel -> Maybe GitLabParam)
-> Maybe AccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe AccessLevel
groupProjectFilter_min_access_level GroupProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"with_custom_attributes", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Bool
groupProjectFilter_with_custom_attributes GroupProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"with_security_reports", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupProjectAttrs -> Maybe Bool
groupProjectFilter_with_security_reports GroupProjectAttrs
filters
    ]
  where
    textToBS :: Text -> Maybe ByteString
textToBS = ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (ByteString -> Maybe ByteString)
-> (Text -> ByteString) -> Text -> Maybe ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
T.encodeUtf8
    showBool :: Bool -> Text
    showBool :: Bool -> Text
showBool Bool
True = Text
"true"
    showBool Bool
False = Text
"false"

-- | Attributes related to listing groups
data ListGroupsAttrs = ListGroupsAttrs
  { ListGroupsAttrs -> Maybe [Int]
listGroupsFilter_skip_groups :: Maybe [Int],
    ListGroupsAttrs -> Maybe Bool
listGroupsFilter_all_available :: Maybe Bool,
    ListGroupsAttrs -> Maybe Text
listGroupsFilter_search :: Maybe Text,
    ListGroupsAttrs -> Maybe GroupOrderBy
listGroupsFilter_order_by :: Maybe GroupOrderBy,
    ListGroupsAttrs -> Maybe SortBy
listGroupsFilter_sort :: Maybe SortBy,
    ListGroupsAttrs -> Maybe Bool
listGroupsFilter_owned :: Maybe Bool,
    ListGroupsAttrs -> Maybe AccessLevel
listGroupsFilter_min_access_level :: Maybe AccessLevel,
    ListGroupsAttrs -> Maybe Bool
listGroupsFilter_top_level_only :: Maybe Bool
  }

-- | The order of groups in search results.
data GroupOrderBy
  = GroupOrderName
  | GroupOrderPath
  | GroupOrderId
  | GroupOrderSimilarity

instance Show GroupOrderBy where
  show :: GroupOrderBy -> [Char]
show GroupOrderBy
GroupOrderName = [Char]
"name"
  show GroupOrderBy
GroupOrderPath = [Char]
"path"
  show GroupOrderBy
GroupOrderId = [Char]
"id"
  show GroupOrderBy
GroupOrderSimilarity = [Char]
"similarity"

listGroupsAttrs :: ListGroupsAttrs -> [GitLabParam]
listGroupsAttrs :: ListGroupsAttrs -> [GitLabParam]
listGroupsAttrs ListGroupsAttrs
filters =
  [Maybe GitLabParam] -> [GitLabParam]
forall a. [Maybe a] -> [a]
catMaybes
    [ (\[Int]
i -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"skip_groups", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack ([Int] -> [Char]
forall a. Show a => a -> [Char]
show [Int]
i)))) ([Int] -> Maybe GitLabParam) -> Maybe [Int] -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ListGroupsAttrs -> Maybe [Int]
listGroupsFilter_skip_groups ListGroupsAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"all_available", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ListGroupsAttrs -> Maybe Bool
listGroupsFilter_all_available ListGroupsAttrs
filters,
      (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"search", Text -> Maybe ByteString
textToBS Text
t)) (Text -> Maybe GitLabParam) -> Maybe Text -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ListGroupsAttrs -> Maybe Text
listGroupsFilter_search ListGroupsAttrs
filters,
      (\GroupOrderBy
grpOrder -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"order_by", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (GroupOrderBy -> [Char]
forall a. Show a => a -> [Char]
show GroupOrderBy
grpOrder)))) (GroupOrderBy -> Maybe GitLabParam)
-> Maybe GroupOrderBy -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ListGroupsAttrs -> Maybe GroupOrderBy
listGroupsFilter_order_by ListGroupsAttrs
filters,
      (\SortBy
sortBy -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"sort", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (SortBy -> [Char]
forall a. Show a => a -> [Char]
show SortBy
sortBy)))) (SortBy -> Maybe GitLabParam) -> Maybe SortBy -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ListGroupsAttrs -> Maybe SortBy
listGroupsFilter_sort ListGroupsAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"owned", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ListGroupsAttrs -> Maybe Bool
listGroupsFilter_owned ListGroupsAttrs
filters,
      (\AccessLevel
accLevel -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"min_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (AccessLevel -> [Char]
forall a. Show a => a -> [Char]
show AccessLevel
accLevel)))) (AccessLevel -> Maybe GitLabParam)
-> Maybe AccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ListGroupsAttrs -> Maybe AccessLevel
listGroupsFilter_min_access_level ListGroupsAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"top_level_only", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< ListGroupsAttrs -> Maybe Bool
listGroupsFilter_top_level_only ListGroupsAttrs
filters
    ]
  where
    textToBS :: Text -> Maybe ByteString
textToBS = ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (ByteString -> Maybe ByteString)
-> (Text -> ByteString) -> Text -> Maybe ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
T.encodeUtf8
    showBool :: Bool -> Text
    showBool :: Bool -> Text
showBool Bool
True = Text
"true"
    showBool Bool
False = Text
"false"

-- | No group filters applied, thereby returning all groups.
defaultListGroupsFilters :: ListGroupsAttrs
defaultListGroupsFilters :: ListGroupsAttrs
defaultListGroupsFilters =
  Maybe [Int]
-> Maybe Bool
-> Maybe Text
-> Maybe GroupOrderBy
-> Maybe SortBy
-> Maybe Bool
-> Maybe AccessLevel
-> Maybe Bool
-> ListGroupsAttrs
ListGroupsAttrs Maybe [Int]
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe GroupOrderBy
forall a. Maybe a
Nothing Maybe SortBy
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe AccessLevel
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing

-- | Attributes related to a group
data GroupAttrs = GroupAttrs
  { -- | The name of the group.
    GroupAttrs -> Maybe Text
groupFilter_name :: Maybe Text,
    -- | The path of the group.
    GroupAttrs -> Maybe Text
groupFilter_path :: Maybe Text,
    -- | Default to Auto DevOps pipeline for all projects within this
    -- group.
    GroupAttrs -> Maybe Bool
groupFilter_auto_devops_enabled :: Maybe Bool,
    -- | Default to the global level default branch protection
    -- setting.
    GroupAttrs -> Maybe BranchProtection
groupFilter_default_branch_protection :: Maybe BranchProtection,
    -- | The group’s description.
    GroupAttrs -> Maybe Text
groupFilter_description :: Maybe Text,
    -- | Disable email notifications.
    GroupAttrs -> Maybe Bool
groupFilter_emails_disabled :: Maybe Bool,
    -- | Enable/disable Large File Storage (LFS) for the projects in
    -- this group.
    GroupAttrs -> Maybe Bool
groupFilter_lfs_enabled :: Maybe Bool,
    -- | Disable the capability of a group from getting mentioned.
    GroupAttrs -> Maybe Bool
groupFilter_mentions_disabled :: Maybe Bool,
    -- | The parent group ID for creating nested group.
    GroupAttrs -> Maybe Int
groupFilter_parent_id :: Maybe Int,
    -- | Determine if developers can create projects in the group. Can
    -- be noone (No one), maintainer (users with the Maintainer role),
    -- or developer (users with the Developer or Maintainer role).
    GroupAttrs -> Maybe AccessLevel
groupFilter_project_creation_level :: Maybe AccessLevel,
    -- | Allow users to request member access.
    GroupAttrs -> Maybe Bool
groupFilter_request_access_enabled :: Maybe Bool,
    -- | Require all users in this group to setup Two-factor
    -- authentication.
    GroupAttrs -> Maybe Bool
groupFilter_require_two_factor_authentication :: Maybe Bool,
    -- | Prevent sharing a project with another group within this
    -- group.
    GroupAttrs -> Maybe Bool
groupFilter_share_with_group_lock :: Maybe Bool,
    -- | Allowed to create subgroups. Can be owner (Owners), or
    -- maintainer (users with the Maintainer role).
    GroupAttrs -> Maybe AccessLevel
groupFilter_subgroup_creation_level :: Maybe AccessLevel,
    -- | Time before Two-factor authentication is enforced (in hours).
    GroupAttrs -> Maybe Int
groupFilter_two_factor_grace_period :: Maybe Int,
    -- | The group’s visibility. Can be private, internal, or public.
    GroupAttrs -> Maybe Visibility
groupFilter_visibility :: Maybe Visibility
  }

-- | A group level branch protection setting.
data BranchProtection
  = -- | Users with the Developer or Maintainer role can: push new
    -- commits, force push changes, delete the branch
    NoProtection
  | -- | Users with the Developer or Maintainer role can: push new commits
    PartialProtection
  | -- | Only users with the Maintainer role can: push new commits
    FullProtection
  | -- | Users with the Maintainer role can: push new commits, force
    -- push changes, accept merge requests; Users with the Developer
    -- role can: accept merge requests
    ProtectAgainstPushes

instance Show BranchProtection where
  show :: BranchProtection -> [Char]
show BranchProtection
NoProtection = [Char]
"0"
  show BranchProtection
PartialProtection = [Char]
"1"
  show BranchProtection
FullProtection = [Char]
"2"
  show BranchProtection
ProtectAgainstPushes = [Char]
"3"

groupAttrs :: GroupAttrs -> [GitLabParam]
groupAttrs :: GroupAttrs -> [GitLabParam]
groupAttrs GroupAttrs
filters =
  [Maybe GitLabParam] -> [GitLabParam]
forall a. [Maybe a] -> [a]
catMaybes
    [ (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"name", Text -> Maybe ByteString
textToBS Text
t)) (Text -> Maybe GitLabParam) -> Maybe Text -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Text
groupFilter_name GroupAttrs
filters,
      (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"path", Text -> Maybe ByteString
textToBS Text
t)) (Text -> Maybe GitLabParam) -> Maybe Text -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Text
groupFilter_path GroupAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"auto_devops_enabled", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Bool
groupFilter_auto_devops_enabled GroupAttrs
filters,
      (\BranchProtection
a -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"default_branch_protection", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (BranchProtection -> [Char]
forall a. Show a => a -> [Char]
show BranchProtection
a)))) (BranchProtection -> Maybe GitLabParam)
-> Maybe BranchProtection -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe BranchProtection
groupFilter_default_branch_protection GroupAttrs
filters,
      (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"description", Text -> Maybe ByteString
textToBS Text
t)) (Text -> Maybe GitLabParam) -> Maybe Text -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Text
groupFilter_description GroupAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"emails_disabled", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Bool
groupFilter_emails_disabled GroupAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"lfs_enabled", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Bool
groupFilter_lfs_enabled GroupAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"mentions_disabled", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Bool
groupFilter_mentions_disabled GroupAttrs
filters,
      (\Int
i -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"parent_id", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i)))) (Int -> Maybe GitLabParam) -> Maybe Int -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Int
groupFilter_parent_id GroupAttrs
filters,
      (\AccessLevel
a -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"project_creation_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (AccessLevel -> [Char]
forall a. Show a => a -> [Char]
show AccessLevel
a)))) (AccessLevel -> Maybe GitLabParam)
-> Maybe AccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe AccessLevel
groupFilter_project_creation_level GroupAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"request_access_enabled", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Bool
groupFilter_request_access_enabled GroupAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"require_two_factor_authentication", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Bool
groupFilter_require_two_factor_authentication GroupAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"share_with_group_lock", Text -> Maybe ByteString
textToBS (Bool -> Text
showBool Bool
b))) (Bool -> Maybe GitLabParam) -> Maybe Bool -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Bool
groupFilter_share_with_group_lock GroupAttrs
filters,
      (\AccessLevel
a -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"subgroup_creation_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (AccessLevel -> [Char]
forall a. Show a => a -> [Char]
show AccessLevel
a)))) (AccessLevel -> Maybe GitLabParam)
-> Maybe AccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe AccessLevel
groupFilter_subgroup_creation_level GroupAttrs
filters,
      (\Int
i -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"two_factor_grace_period", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i)))) (Int -> Maybe GitLabParam) -> Maybe Int -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Int
groupFilter_two_factor_grace_period GroupAttrs
filters,
      (\Visibility
a -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"visibility", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (Visibility -> [Char]
forall a. Show a => a -> [Char]
show Visibility
a)))) (Visibility -> Maybe GitLabParam)
-> Maybe Visibility -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< GroupAttrs -> Maybe Visibility
groupFilter_visibility GroupAttrs
filters
    ]
  where
    textToBS :: Text -> Maybe ByteString
textToBS = ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (ByteString -> Maybe ByteString)
-> (Text -> ByteString) -> Text -> Maybe ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
T.encodeUtf8
    showBool :: Bool -> Text
    showBool :: Bool -> Text
showBool Bool
True = Text
"true"
    showBool Bool
False = Text
"false"

-- | No group filters applied.
defaultGroupFilters ::
  GroupAttrs
defaultGroupFilters :: GroupAttrs
defaultGroupFilters =
  Maybe Text
-> Maybe Text
-> Maybe Bool
-> Maybe BranchProtection
-> Maybe Text
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Int
-> Maybe AccessLevel
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe AccessLevel
-> Maybe Int
-> Maybe Visibility
-> GroupAttrs
GroupAttrs Maybe Text
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe BranchProtection
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Int
forall a. Maybe a
Nothing Maybe AccessLevel
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe AccessLevel
forall a. Maybe a
Nothing Maybe Int
forall a. Maybe a
Nothing Maybe Visibility
forall a. Maybe a
Nothing