{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}

-- |
-- Module      : Projects
-- Description : Queries about projects
-- Copyright   : (c) Rob Stewart, Heriot-Watt University, 2019
-- License     : BSD3
-- Maintainer  : robstewart57@gmail.com
-- Stability   : stable
module GitLab.API.Projects
  ( allProjects,
    projectForks,
    searchProjectId,
    projectsWithName,
    projectsWithNameAndUser,
    multipleCommitters,
    commitsEmailAddresses,
    commitsEmailAddresses',
    userProjects,
    userProjects',
    projectOfIssue,
    issuesCreatedByUser,
    issuesOnForks,
    projectMemebersCount,
    projectCISuccess,
    namespacePathToUserId,
    projectDiffs,
    projectDiffs',
    addGroupToProject,
    transferProject,
    transferProject',
    editProject,
    editProject',
    defaultEditProjectAttrs,
    EditProjectAttrs (..),
    EnabledDisabled (..),
    AutoDeployStrategy (..),
    GitStrategy (..),
    ProjectSettingAccessLevel (..),
    MergeMethod (..),
    SquashOption (..),
  )
where

import qualified Data.ByteString.Lazy as BSL
import Data.Either
import Data.List
import Data.Maybe
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import GHC.Generics
import GitLab.API.Commits
import GitLab.API.Issues
import GitLab.API.Members
import GitLab.API.Pipelines
import GitLab.API.Users
import GitLab.Types
import GitLab.WebRequests.GitLabWebCalls
import Network.HTTP.Client
import Network.HTTP.Types.URI

-- | gets all projects.
allProjects :: GitLab [Project]
allProjects :: GitLab [Project]
allProjects =
  [Project] -> Either (Response ByteString) [Project] -> [Project]
forall b a. b -> Either a b -> b
fromRight ([Char] -> [Project]
forall a. HasCallStack => [Char] -> a
error [Char]
"allProjects error")
    (Either (Response ByteString) [Project] -> [Project])
-> ReaderT GitLabState IO (Either (Response ByteString) [Project])
-> GitLab [Project]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> [GitLabParam]
-> ReaderT GitLabState IO (Either (Response ByteString) [Project])
forall a.
FromJSON a =>
Text -> [GitLabParam] -> GitLab (Either (Response ByteString) [a])
gitlabGetMany Text
"/projects" [(ByteString
"statistics", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
"true")]

-- | gets all forks of a project. Supports use of namespaces.
--
-- > projectForks "project1"
-- > projectForks "group1/project1"
projectForks ::
  -- | name or namespace of the project
  Text ->
  GitLab (Either (Response BSL.ByteString) [Project])
projectForks :: Text
-> ReaderT GitLabState IO (Either (Response ByteString) [Project])
projectForks Text
projectName = do
  let urlPath :: Text
urlPath =
        Text
"/projects/"
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> ByteString -> Text
T.decodeUtf8 (Bool -> ByteString -> ByteString
urlEncode Bool
False (Text -> ByteString
T.encodeUtf8 Text
projectName))
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/forks"
  Text
-> [GitLabParam]
-> ReaderT GitLabState IO (Either (Response ByteString) [Project])
forall a.
FromJSON a =>
Text -> [GitLabParam] -> GitLab (Either (Response ByteString) [a])
gitlabGetMany Text
urlPath []

-- | searches for a 'Project' with the given project ID, returns
-- 'Nothing' if a project with the given ID is not found.
searchProjectId ::
  -- | project ID
  Int ->
  GitLab (Either (Response BSL.ByteString) (Maybe Project))
searchProjectId :: Int -> GitLab (Either (Response ByteString) (Maybe Project))
searchProjectId Int
projectId = do
  let urlPath :: Text
urlPath = [Char] -> Text
T.pack ([Char]
"/projects/" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Int -> [Char]
forall a. Show a => a -> [Char]
show Int
projectId)
  Text
-> [GitLabParam]
-> GitLab (Either (Response ByteString) (Maybe Project))
forall a.
FromJSON a =>
Text
-> [GitLabParam] -> GitLab (Either (Response ByteString) (Maybe a))
gitlabGetOne Text
urlPath [(ByteString
"statistics", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
"true")]

-- | gets all projects with the given project name.
--
-- > projectsWithName "project1"
projectsWithName ::
  -- | project name being searched for.
  Text ->
  GitLab [Project]
projectsWithName :: Text -> GitLab [Project]
projectsWithName Text
projectName = do
  Either (Response ByteString) [Project]
results <- Text
-> [GitLabParam]
-> ReaderT GitLabState IO (Either (Response ByteString) [Project])
forall a.
FromJSON a =>
Text -> [GitLabParam] -> GitLab (Either (Response ByteString) [a])
gitlabGetMany Text
"/projects" [(ByteString
"search", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Text -> ByteString
T.encodeUtf8 Text
projectName))]
  case Either (Response ByteString) [Project]
results of
    Left Response ByteString
_ -> [Char] -> GitLab [Project]
forall a. HasCallStack => [Char] -> a
error [Char]
"projectsWithName error"
    Right [Project]
projects ->
      [Project] -> GitLab [Project]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Project] -> GitLab [Project]) -> [Project] -> GitLab [Project]
forall a b. (a -> b) -> a -> b
$
        (Project -> Bool) -> [Project] -> [Project]
forall a. (a -> Bool) -> [a] -> [a]
filter (\Project
project -> Text
projectName Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Project -> Text
project_path Project
project) [Project]
projects

-- | gets a project with the given name for the given username. E.g.
--
-- > projectsWithNameAndUser "user1" "project1"
--
-- looks for "user1/project1"
projectsWithNameAndUser :: Text -> Text -> GitLab (Either (Response BSL.ByteString) (Maybe Project))
projectsWithNameAndUser :: Text
-> Text -> GitLab (Either (Response ByteString) (Maybe Project))
projectsWithNameAndUser Text
username Text
projectName =
  Text
-> [GitLabParam]
-> GitLab (Either (Response ByteString) (Maybe Project))
forall a.
FromJSON a =>
Text
-> [GitLabParam] -> GitLab (Either (Response ByteString) (Maybe a))
gitlabGetOne
    ( Text
"/projects/"
        Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> ByteString -> Text
T.decodeUtf8
          (Bool -> ByteString -> ByteString
urlEncode Bool
False (Text -> ByteString
T.encodeUtf8 (Text
username Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
projectName)))
    )
    [(ByteString
"statistics", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
"true")]

-- | returns 'True' if a project has multiple committers, according to
-- the email addresses of the commits.
multipleCommitters :: Project -> GitLab Bool
multipleCommitters :: Project -> GitLab Bool
multipleCommitters Project
project = do
  [Text]
emailAddresses <- Project -> GitLab [Text]
commitsEmailAddresses Project
project
  Bool -> GitLab Bool
forall (m :: * -> *) a. Monad m => a -> m a
return ([Text] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([Text] -> [Text]
forall a. Eq a => [a] -> [a]
nub [Text]
emailAddresses) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1)

-- | gets the email addresses in the author information in all commit
-- for a project.
commitsEmailAddresses :: Project -> GitLab [Text]
commitsEmailAddresses :: Project -> GitLab [Text]
commitsEmailAddresses Project
project = do
  Either (Response ByteString) [Text]
result <- Int -> GitLab (Either (Response ByteString) [Text])
commitsEmailAddresses' (Project -> Int
project_id Project
project)
  [Text] -> GitLab [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Text] -> Either (Response ByteString) [Text] -> [Text]
forall b a. b -> Either a b -> b
fromRight ([Char] -> [Text]
forall a. HasCallStack => [Char] -> a
error [Char]
"commitsEmailAddresses error") Either (Response ByteString) [Text]
result)

-- | gets the email addresses in the author information in all commit
-- for a project defined by the project's ID.
commitsEmailAddresses' :: Int -> GitLab (Either (Response BSL.ByteString) [Text])
commitsEmailAddresses' :: Int -> GitLab (Either (Response ByteString) [Text])
commitsEmailAddresses' Int
projectId = do
  -- (commits :: [Commit]) <- projectCommits' projectId
  Either (Response ByteString) [Commit]
attempt <- Int -> GitLab (Either (Response ByteString) [Commit])
projectCommits' Int
projectId
  case Either (Response ByteString) [Commit]
attempt of
    Left Response ByteString
resp -> Either (Response ByteString) [Text]
-> GitLab (Either (Response ByteString) [Text])
forall (m :: * -> *) a. Monad m => a -> m a
return (Response ByteString -> Either (Response ByteString) [Text]
forall a b. a -> Either a b
Left Response ByteString
resp)
    Right ([Commit]
commits :: [Commit]) ->
      Either (Response ByteString) [Text]
-> GitLab (Either (Response ByteString) [Text])
forall (m :: * -> *) a. Monad m => a -> m a
return ([Text] -> Either (Response ByteString) [Text]
forall a b. b -> Either a b
Right ((Commit -> Text) -> [Commit] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map Commit -> Text
author_email [Commit]
commits))

-- | gets all projects for a user given their username.
--
-- > userProjects "harry"
userProjects' :: Text -> GitLab (Maybe [Project])
userProjects' :: Text -> GitLab (Maybe [Project])
userProjects' Text
username = do
  Maybe User
userMaybe <- Text -> GitLab (Maybe User)
searchUser Text
username
  case Maybe User
userMaybe of
    Maybe User
Nothing -> Maybe [Project] -> GitLab (Maybe [Project])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Project]
forall a. Maybe a
Nothing
    Just User
usr -> do
      Either (Response ByteString) [Project]
result <- Text
-> [GitLabParam]
-> ReaderT GitLabState IO (Either (Response ByteString) [Project])
forall a.
FromJSON a =>
Text -> [GitLabParam] -> GitLab (Either (Response ByteString) [a])
gitlabGetMany (Int -> Text
forall a. Show a => a -> Text
urlPath (User -> Int
user_id User
usr)) []
      case Either (Response ByteString) [Project]
result of
        Left Response ByteString
_ -> [Char] -> GitLab (Maybe [Project])
forall a. HasCallStack => [Char] -> a
error [Char]
"userProjects' error"
        Right [Project]
projs -> Maybe [Project] -> GitLab (Maybe [Project])
forall (m :: * -> *) a. Monad m => a -> m a
return ([Project] -> Maybe [Project]
forall a. a -> Maybe a
Just [Project]
projs)
  where
    urlPath :: a -> Text
urlPath a
usrId = Text
"/users/" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (a -> [Char]
forall a. Show a => a -> [Char]
show a
usrId) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/projects"

-- | gets all projects for a user.
--
-- > userProjects myUser
userProjects :: User -> GitLab (Maybe [Project])
userProjects :: User -> GitLab (Maybe [Project])
userProjects User
theUser =
  Text -> GitLab (Maybe [Project])
userProjects' (User -> Text
user_username User
theUser)

-- | gets the 'GitLab.Types.Project' against which the given 'Issue'
-- was created.
projectOfIssue :: Issue -> GitLab Project
projectOfIssue :: Issue -> GitLab Project
projectOfIssue Issue
issue = do
  Either (Response ByteString) (Maybe Project)
result <- Int -> GitLab (Either (Response ByteString) (Maybe Project))
searchProjectId (Issue -> Int
issue_project_id Issue
issue)
  case Maybe Project
-> Either (Response ByteString) (Maybe Project) -> Maybe Project
forall b a. b -> Either a b -> b
fromRight ([Char] -> Maybe Project
forall a. HasCallStack => [Char] -> a
error [Char]
"projectOfIssue error") Either (Response ByteString) (Maybe Project)
result of
    Maybe Project
Nothing -> [Char] -> GitLab Project
forall a. HasCallStack => [Char] -> a
error [Char]
"projectOfIssue error"
    Just Project
proj -> Project -> GitLab Project
forall (m :: * -> *) a. Monad m => a -> m a
return Project
proj

-- | finds all issues created by a user.
--
-- > issuesCreatedByUser "user1"
--
-- returns a (user,projects) tuple, where user is the 'User' found
-- for the given searched username, and a list of 'Project's that the
-- user has created issues for.
issuesCreatedByUser :: Text -> GitLab (Maybe (User, [Project]))
issuesCreatedByUser :: Text -> GitLab (Maybe (User, [Project]))
issuesCreatedByUser Text
username = do
  Maybe User
user_maybe <- Text -> GitLab (Maybe User)
searchUser Text
username
  case Maybe User
user_maybe of
    Maybe User
Nothing -> Maybe (User, [Project]) -> GitLab (Maybe (User, [Project]))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (User, [Project])
forall a. Maybe a
Nothing
    Just User
usr -> do
      [Issue]
usersIssues <- User -> GitLab [Issue]
userIssues User
usr
      [Project]
projects <- (Issue -> GitLab Project) -> [Issue] -> GitLab [Project]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Issue -> GitLab Project
projectOfIssue [Issue]
usersIssues
      Maybe (User, [Project]) -> GitLab (Maybe (User, [Project]))
forall (m :: * -> *) a. Monad m => a -> m a
return ((User, [Project]) -> Maybe (User, [Project])
forall a. a -> Maybe a
Just (User
usr, [Project]
projects))

-- | searches for all projects with the given name, and returns a list
-- of triples of: 1) the found project, 2) the list of issues for the
-- found projects, and 3) a list of users who've created issues.
issuesOnForks ::
  -- | name or namespace of the project
  Text ->
  GitLab [(Project, [Issue], [User])]
issuesOnForks :: Text -> GitLab [(Project, [Issue], [User])]
issuesOnForks Text
projectName = do
  [Project]
projects <- Text -> GitLab [Project]
projectsWithName Text
projectName
  (Project -> ReaderT GitLabState IO (Project, [Issue], [User]))
-> [Project] -> GitLab [(Project, [Issue], [User])]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Project -> ReaderT GitLabState IO (Project, [Issue], [User])
processProject [Project]
projects
  where
    processProject ::
      Project ->
      GitLab (Project, [Issue], [User])
    processProject :: Project -> ReaderT GitLabState IO (Project, [Issue], [User])
processProject Project
proj = do
      ([Issue]
openIssues :: [Issue]) <- Project -> IssueAttrs -> GitLab [Issue]
projectIssues Project
proj IssueAttrs
defaultIssueFilters
      let authors :: [User]
authors = (Issue -> User) -> [Issue] -> [User]
forall a b. (a -> b) -> [a] -> [b]
map Issue -> User
issue_author [Issue]
openIssues
      (Project, [Issue], [User])
-> ReaderT GitLabState IO (Project, [Issue], [User])
forall (m :: * -> *) a. Monad m => a -> m a
return (Project
proj, [Issue]
openIssues, [User]
authors)

-- | returns a (namespace,members) tuple for the given 'Project',
-- where namespace is the namespace of the project
-- e.g. "user1/project1", and members is a list of (username,name)
-- tuples about all members of the project.
projectMemebersCount :: Project -> GitLab (Text, [(Text, Text)])
projectMemebersCount :: Project -> GitLab (Text, [(Text, Text)])
projectMemebersCount Project
project = do
  [(Text, Text)]
friends <- ReaderT GitLabState IO [(Text, Text)]
count
  (Text, [(Text, Text)]) -> GitLab (Text, [(Text, Text)])
forall (m :: * -> *) a. Monad m => a -> m a
return (Namespace -> Text
namespace_name (Project -> Namespace
namespace Project
project), [(Text, Text)]
friends)
  where
    count :: ReaderT GitLabState IO [(Text, Text)]
count = do
      let addr :: Text
addr =
            Text
"/projects/" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show (Project -> Int
project_id Project
project)) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/members/all"
      ([Member]
res :: [Member]) <- [Member] -> Either (Response ByteString) [Member] -> [Member]
forall b a. b -> Either a b -> b
fromRight ([Char] -> [Member]
forall a. HasCallStack => [Char] -> a
error [Char]
"projectMembersCount error") (Either (Response ByteString) [Member] -> [Member])
-> ReaderT GitLabState IO (Either (Response ByteString) [Member])
-> ReaderT GitLabState IO [Member]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> [GitLabParam]
-> ReaderT GitLabState IO (Either (Response ByteString) [Member])
forall a.
FromJSON a =>
Text -> [GitLabParam] -> GitLab (Either (Response ByteString) [a])
gitlabGetMany Text
addr []
      [(Text, Text)] -> ReaderT GitLabState IO [(Text, Text)]
forall (m :: * -> *) a. Monad m => a -> m a
return ((Member -> (Text, Text)) -> [Member] -> [(Text, Text)]
forall a b. (a -> b) -> [a] -> [b]
map (\Member
x -> (Member -> Text
member_username Member
x, Member -> Text
member_name Member
x)) [Member]
res)

-- | returns 'True' is the last commit for a project passes all
-- continuous integration tests.
projectCISuccess ::
  -- | the name or namespace of the project
  Project ->
  GitLab Bool
projectCISuccess :: Project -> GitLab Bool
projectCISuccess Project
project = do
  [Pipeline]
pipes <- Project -> GitLab [Pipeline]
pipelines Project
project
  case [Pipeline]
pipes of
    [] -> Bool -> GitLab Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
    (Pipeline
x : [Pipeline]
_) -> Bool -> GitLab Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (Pipeline -> Text
pipeline_status Pipeline
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"success")

-- | searches for a username, and returns a user ID for that user, or
-- 'Nothing' if a user cannot be found.
namespacePathToUserId ::
  -- | name or namespace of project
  Text ->
  GitLab (Maybe Int)
namespacePathToUserId :: Text -> GitLab (Maybe Int)
namespacePathToUserId Text
namespacePath = do
  Maybe User
user_maybe <- Text -> GitLab (Maybe User)
searchUser Text
namespacePath
  case Maybe User
user_maybe of
    Maybe User
Nothing -> Maybe Int -> GitLab (Maybe Int)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Int
forall a. Maybe a
Nothing
    Just User
usr -> Maybe Int -> GitLab (Maybe Int)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Maybe Int
forall a. a -> Maybe a
Just (User -> Int
user_id User
usr))

-- | gets all diffs in a project for a given commit SHA.
projectDiffs :: Project -> Text -> GitLab (Either (Response BSL.ByteString) [Diff])
projectDiffs :: Project -> Text -> GitLab (Either (Response ByteString) [Diff])
projectDiffs Project
proj =
  Int -> Text -> GitLab (Either (Response ByteString) [Diff])
projectDiffs' (Project -> Int
project_id Project
proj)

-- | gets all diffs in a project for a given project ID, for a given
-- commit SHA.
projectDiffs' :: Int -> Text -> GitLab (Either (Response BSL.ByteString) [Diff])
projectDiffs' :: Int -> Text -> GitLab (Either (Response ByteString) [Diff])
projectDiffs' Int
projId Text
commitSha =
  Text
-> [GitLabParam] -> GitLab (Either (Response ByteString) [Diff])
forall a.
FromJSON a =>
Text -> [GitLabParam] -> GitLab (Either (Response ByteString) [a])
gitlabGetMany
    ( Text
"/projects/"
        Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
projId)
        Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/repository/commits/"
        Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
commitSha
        Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/diff/"
    )
    []

-- | add a group to a project.
addGroupToProject ::
  -- | group ID
  Int ->
  -- | project ID
  Int ->
  -- | level of access granted
  AccessLevel ->
  GitLab (Either (Response BSL.ByteString) (Maybe GroupShare))
addGroupToProject :: Int
-> Int
-> AccessLevel
-> GitLab (Either (Response ByteString) (Maybe GroupShare))
addGroupToProject Int
groupId Int
projectId AccessLevel
access =
  Text
-> [GitLabParam]
-> GitLab (Either (Response ByteString) (Maybe GroupShare))
forall a.
FromJSON a =>
Text
-> [GitLabParam] -> GitLab (Either (Response ByteString) (Maybe a))
gitlabPost Text
addr [GitLabParam]
params
  where
    params :: [GitLabParam]
    params :: [GitLabParam]
params =
      [ (ByteString
"group_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
groupId)))),
        (ByteString
"group_access", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Text -> ByteString
T.encodeUtf8 ([Char] -> Text
T.pack (AccessLevel -> [Char]
forall a. Show a => a -> [Char]
show AccessLevel
access))))
      ]
    addr :: Text
addr =
      Text
"/projects/"
        Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
projectId)
        Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/share"

-- | transfer a project to a new namespace.
transferProject ::
  -- | project
  Project ->
  -- | namespace where to transfer project to
  Text ->
  GitLab (Either (Response BSL.ByteString) Project)
transferProject :: Project -> Text -> GitLab (Either (Response ByteString) Project)
transferProject Project
prj = Int -> Text -> GitLab (Either (Response ByteString) Project)
transferProject' (Project -> Int
project_id Project
prj)

-- | edit a project.
transferProject' ::
  -- | project ID
  Int ->
  -- | namespace where to transfer project to
  Text ->
  GitLab (Either (Response BSL.ByteString) Project)
transferProject' :: Int -> Text -> GitLab (Either (Response ByteString) Project)
transferProject' Int
projId Text
namespaceString = do
  let urlPath :: Text
urlPath =
        Text
"/projects/"
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
projId)
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"/transfer"
  Either (Response ByteString) (Maybe Project)
result <-
    Text
-> [GitLabParam]
-> GitLab (Either (Response ByteString) (Maybe Project))
forall a.
FromJSON a =>
Text
-> [GitLabParam] -> GitLab (Either (Response ByteString) (Maybe a))
gitlabPut
      Text
urlPath
      [ (ByteString
"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
projId)))),
        (ByteString
"namespace", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Text -> ByteString
T.encodeUtf8 Text
namespaceString))
      ]
  case Either (Response ByteString) (Maybe Project)
result of
    Left Response ByteString
resp -> Either (Response ByteString) Project
-> GitLab (Either (Response ByteString) Project)
forall (m :: * -> *) a. Monad m => a -> m a
return (Response ByteString -> Either (Response ByteString) Project
forall a b. a -> Either a b
Left Response ByteString
resp)
    Right Maybe Project
Nothing -> [Char] -> GitLab (Either (Response ByteString) Project)
forall a. HasCallStack => [Char] -> a
error [Char]
"transferProject error"
    Right (Just Project
proj) -> Either (Response ByteString) Project
-> GitLab (Either (Response ByteString) Project)
forall (m :: * -> *) a. Monad m => a -> m a
return (Project -> Either (Response ByteString) Project
forall a b. b -> Either a b
Right Project
proj)

-- | edit a project.
editProject ::
  -- | project
  Project ->
  -- | EditProjectAttributes
  EditProjectAttrs ->
  GitLab (Either (Response BSL.ByteString) Project)
editProject :: Project
-> EditProjectAttrs
-> GitLab (Either (Response ByteString) Project)
editProject Project
prj = Int
-> EditProjectAttrs
-> GitLab (Either (Response ByteString) Project)
editProject' (Project -> Int
project_id Project
prj)

-- | edit a project.
editProject' ::
  -- | project ID
  Int ->
  -- | EditProjectAttributes
  EditProjectAttrs ->
  GitLab (Either (Response BSL.ByteString) Project)
editProject' :: Int
-> EditProjectAttrs
-> GitLab (Either (Response ByteString) Project)
editProject' Int
projId EditProjectAttrs
attrs = do
  let urlPath :: Text
urlPath =
        Text
"/projects/"
          Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
projId)
  Either (Response ByteString) (Maybe Project)
result <-
    Text
-> [GitLabParam]
-> GitLab (Either (Response ByteString) (Maybe Project))
forall a.
FromJSON a =>
Text
-> [GitLabParam] -> GitLab (Either (Response ByteString) (Maybe a))
gitlabPut
      Text
urlPath
      (EditProjectAttrs -> [GitLabParam]
editProjectAttrs EditProjectAttrs
attrs)
  case Either (Response ByteString) (Maybe Project)
result of
    Left Response ByteString
resp -> Either (Response ByteString) Project
-> GitLab (Either (Response ByteString) Project)
forall (m :: * -> *) a. Monad m => a -> m a
return (Response ByteString -> Either (Response ByteString) Project
forall a b. a -> Either a b
Left Response ByteString
resp)
    Right Maybe Project
Nothing -> [Char] -> GitLab (Either (Response ByteString) Project)
forall a. HasCallStack => [Char] -> a
error [Char]
"editProject error"
    Right (Just Project
proj) -> Either (Response ByteString) Project
-> GitLab (Either (Response ByteString) Project)
forall (m :: * -> *) a. Monad m => a -> m a
return (Project -> Either (Response ByteString) Project
forall a b. b -> Either a b
Right Project
proj)

-- | A default set of project attributes to override with the
-- 'editProject' functions.
defaultEditProjectAttrs ::
  -- | project ID
  Int ->
  EditProjectAttrs
defaultEditProjectAttrs :: Int -> EditProjectAttrs
defaultEditProjectAttrs Int
projId =
  Maybe Bool
-> Maybe Text
-> Maybe Int
-> Maybe EnabledDisabled
-> Maybe AutoDeployStrategy
-> Maybe Bool
-> Maybe Bool
-> Maybe Text
-> Maybe GitStrategy
-> Maybe Int
-> Maybe ProjectSettingAccessLevel
-> Maybe Text
-> Maybe Int
-> Maybe Bool
-> Maybe ProjectSettingAccessLevel
-> Maybe Text
-> Maybe Text
-> Maybe Bool
-> Maybe Text
-> Maybe ProjectSettingAccessLevel
-> Int
-> Maybe Text
-> Maybe ProjectSettingAccessLevel
-> Maybe Bool
-> Maybe MergeMethod
-> Maybe ProjectSettingAccessLevel
-> Maybe Bool
-> Maybe Bool
-> Maybe Int
-> Maybe Bool
-> Maybe Text
-> Maybe ProjectSettingAccessLevel
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe ProjectSettingAccessLevel
-> Maybe ProjectSettingAccessLevel
-> Maybe Bool
-> Maybe Text
-> Maybe Bool
-> Maybe Bool
-> Maybe ProjectSettingAccessLevel
-> Maybe Text
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe ProjectSettingAccessLevel
-> Maybe SquashOption
-> Maybe Text
-> Maybe Visibility
-> Maybe ProjectSettingAccessLevel
-> Maybe Text
-> Maybe Text
-> Maybe Bool
-> EditProjectAttrs
EditProjectAttrs Maybe Bool
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Int
forall a. Maybe a
Nothing Maybe EnabledDisabled
forall a. Maybe a
Nothing Maybe AutoDeployStrategy
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe GitStrategy
forall a. Maybe a
Nothing Maybe Int
forall a. Maybe a
Nothing Maybe ProjectSettingAccessLevel
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Int
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe ProjectSettingAccessLevel
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe ProjectSettingAccessLevel
forall a. Maybe a
Nothing Int
projId Maybe Text
forall a. Maybe a
Nothing Maybe ProjectSettingAccessLevel
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing Maybe MergeMethod
forall a. Maybe a
Nothing Maybe ProjectSettingAccessLevel
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 Bool
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe ProjectSettingAccessLevel
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 ProjectSettingAccessLevel
forall a. Maybe a
Nothing Maybe ProjectSettingAccessLevel
forall a. Maybe a
Nothing Maybe Bool
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 ProjectSettingAccessLevel
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 ProjectSettingAccessLevel
forall a. Maybe a
Nothing Maybe SquashOption
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Visibility
forall a. Maybe a
Nothing Maybe ProjectSettingAccessLevel
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing Maybe Bool
forall a. Maybe a
Nothing

editProjectAttrs :: EditProjectAttrs -> [GitLabParam]
editProjectAttrs :: EditProjectAttrs -> [GitLabParam]
editProjectAttrs EditProjectAttrs
filters =
  [Maybe GitLabParam] -> [GitLabParam]
forall a. [Maybe a] -> [a]
catMaybes
    [ (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"allow_merge_on_skipped_pipeline", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_allow_merge_on_skipped_pipeline EditProjectAttrs
filters,
      (\Text
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"analytics_access_level", 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
=<< EditProjectAttrs -> Maybe Text
project_edit_analytics_access_level EditProjectAttrs
filters,
      (\Int
i -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"approvals_before_merge", 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
=<< EditProjectAttrs -> Maybe Int
project_edit_approvals_before_merge EditProjectAttrs
filters,
      (\EnabledDisabled
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"auto_cancel_pending_pipelines", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (EnabledDisabled -> [Char]
forall a. Show a => a -> [Char]
show EnabledDisabled
x))))
        (EnabledDisabled -> Maybe GitLabParam)
-> Maybe EnabledDisabled -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe EnabledDisabled
project_edit_auto_cancel_pending_pipelines
          EditProjectAttrs
filters,
      (\AutoDeployStrategy
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"auto_devops_deploy_strategy", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (AutoDeployStrategy -> [Char]
forall a. Show a => a -> [Char]
show AutoDeployStrategy
x))))
        (AutoDeployStrategy -> Maybe GitLabParam)
-> Maybe AutoDeployStrategy -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe AutoDeployStrategy
project_edit_auto_devops_deploy_strategy EditProjectAttrs
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
=<< EditProjectAttrs -> Maybe Bool
project_edit_auto_devops_enabled EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"autoclose_referenced_issues", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_autoclose_referenced_issues EditProjectAttrs
filters,
      (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"build_coverage_regex", 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
=<< EditProjectAttrs -> Maybe Text
project_edit_build_coverage_regex EditProjectAttrs
filters,
      (\GitStrategy
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"build_git_strategy", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (GitStrategy -> [Char]
forall a. Show a => a -> [Char]
show GitStrategy
x)))) (GitStrategy -> Maybe GitLabParam)
-> Maybe GitStrategy -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe GitStrategy
project_edit_build_git_strategy EditProjectAttrs
filters,
      (\Int
i -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"build_timeout", 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
=<< EditProjectAttrs -> Maybe Int
project_edit_build_timeout EditProjectAttrs
filters,
      (\ProjectSettingAccessLevel
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"builds_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (ProjectSettingAccessLevel -> [Char]
forall a. Show a => a -> [Char]
show ProjectSettingAccessLevel
x)))) (ProjectSettingAccessLevel -> Maybe GitLabParam)
-> Maybe ProjectSettingAccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_builds_access_level EditProjectAttrs
filters,
      (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"ci_config_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
=<< EditProjectAttrs -> Maybe Text
project_edit_ci_config_path EditProjectAttrs
filters,
      (\Int
i -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"ci_default_git_depth", 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
=<< EditProjectAttrs -> Maybe Int
project_edit_ci_default_git_depth EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"ci_forward_deployment_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
=<< EditProjectAttrs -> Maybe Bool
project_edit_ci_forward_deployment_enabled EditProjectAttrs
filters,
      (\ProjectSettingAccessLevel
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"container_registry_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (ProjectSettingAccessLevel -> [Char]
forall a. Show a => a -> [Char]
show ProjectSettingAccessLevel
x)))) (ProjectSettingAccessLevel -> Maybe GitLabParam)
-> Maybe ProjectSettingAccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_container_registry_access_level EditProjectAttrs
filters,
      (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"default_branch", 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
=<< EditProjectAttrs -> Maybe Text
project_edit_default_branch EditProjectAttrs
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
=<< EditProjectAttrs -> Maybe Text
project_edit_description EditProjectAttrs
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
=<< EditProjectAttrs -> Maybe Bool
project_edit_emails_disabled EditProjectAttrs
filters,
      (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"external_authorization_classification_label", 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
=<< EditProjectAttrs -> Maybe Text
project_edit_external_authorization_classification_label EditProjectAttrs
filters,
      (\ProjectSettingAccessLevel
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"forking_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (ProjectSettingAccessLevel -> [Char]
forall a. Show a => a -> [Char]
show ProjectSettingAccessLevel
x)))) (ProjectSettingAccessLevel -> Maybe GitLabParam)
-> Maybe ProjectSettingAccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_forking_access_level EditProjectAttrs
filters,
      (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 (EditProjectAttrs -> Int
project_edit_id EditProjectAttrs
filters))))),
      (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"import_url", 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
=<< EditProjectAttrs -> Maybe Text
project_edit_import_url EditProjectAttrs
filters,
      (\ProjectSettingAccessLevel
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"issues_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (ProjectSettingAccessLevel -> [Char]
forall a. Show a => a -> [Char]
show ProjectSettingAccessLevel
x)))) (ProjectSettingAccessLevel -> Maybe GitLabParam)
-> Maybe ProjectSettingAccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_issues_access_level EditProjectAttrs
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
=<< EditProjectAttrs -> Maybe Bool
project_edit_lfs_enabled EditProjectAttrs
filters,
      (\MergeMethod
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"merge_method", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (MergeMethod -> [Char]
forall a. Show a => a -> [Char]
show MergeMethod
x)))) (MergeMethod -> Maybe GitLabParam)
-> Maybe MergeMethod -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe MergeMethod
project_edit_merge_method EditProjectAttrs
filters,
      (\ProjectSettingAccessLevel
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"merge_requests_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (ProjectSettingAccessLevel -> [Char]
forall a. Show a => a -> [Char]
show ProjectSettingAccessLevel
x)))) (ProjectSettingAccessLevel -> Maybe GitLabParam)
-> Maybe ProjectSettingAccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_merge_requests_access_level EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"mirror_overwrites_diverged_branches", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_mirror_overwrites_diverged_branches EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"mirror_trigger_builds", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_mirror_trigger_builds EditProjectAttrs
filters,
      (\Int
i -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"mirror_user_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
=<< EditProjectAttrs -> Maybe Int
project_edit_mirror_user_id EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"mirror", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_mirror EditProjectAttrs
filters,
      (\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
=<< EditProjectAttrs -> Maybe Text
project_edit_name EditProjectAttrs
filters,
      (\ProjectSettingAccessLevel
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"operations_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (ProjectSettingAccessLevel -> [Char]
forall a. Show a => a -> [Char]
show ProjectSettingAccessLevel
x)))) (ProjectSettingAccessLevel -> Maybe GitLabParam)
-> Maybe ProjectSettingAccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_operations_access_level EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"only_allow_merge_if_all_discussions_are_resolved", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_only_allow_merge_if_all_discussions_are_resolved EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"only_allow_merge_if_pipeline_succeeds", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_only_allow_merge_if_pipeline_succeeds EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"only_mirror_protected_branches", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_only_mirror_protected_branches EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"packages_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
=<< EditProjectAttrs -> Maybe Bool
project_edit_packages_enabled EditProjectAttrs
filters,
      (\ProjectSettingAccessLevel
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"pages_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (ProjectSettingAccessLevel -> [Char]
forall a. Show a => a -> [Char]
show ProjectSettingAccessLevel
x)))) (ProjectSettingAccessLevel -> Maybe GitLabParam)
-> Maybe ProjectSettingAccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_pages_access_level EditProjectAttrs
filters,
      (\ProjectSettingAccessLevel
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"requirements_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (ProjectSettingAccessLevel -> [Char]
forall a. Show a => a -> [Char]
show ProjectSettingAccessLevel
x)))) (ProjectSettingAccessLevel -> Maybe GitLabParam)
-> Maybe ProjectSettingAccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_requirements_access_level EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"restrict_user_defined_variables", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_restrict_user_defined_variables EditProjectAttrs
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
=<< EditProjectAttrs -> Maybe Text
project_edit_path EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"public_builds", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_public_builds EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"remove_source_branch_after_merge", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_remove_source_branch_after_merge EditProjectAttrs
filters,
      (\ProjectSettingAccessLevel
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"repository_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (ProjectSettingAccessLevel -> [Char]
forall a. Show a => a -> [Char]
show ProjectSettingAccessLevel
x)))) (ProjectSettingAccessLevel -> Maybe GitLabParam)
-> Maybe ProjectSettingAccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_repository_access_level EditProjectAttrs
filters,
      (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"repository_storage", 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
=<< EditProjectAttrs -> Maybe Text
project_edit_repository_storage EditProjectAttrs
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
=<< EditProjectAttrs -> Maybe Bool
project_edit_request_access_enabled EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"resolve_outdated_diff_discussions", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_resolve_outdated_diff_discussions EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"service_desk_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
=<< EditProjectAttrs -> Maybe Bool
project_edit_service_desk_enabled EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"shared_runners_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
=<< EditProjectAttrs -> Maybe Bool
project_edit_shared_runners_enabled EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"show_default_award_emojis", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_show_default_award_emojis EditProjectAttrs
filters,
      (\ProjectSettingAccessLevel
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"snippets_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (ProjectSettingAccessLevel -> [Char]
forall a. Show a => a -> [Char]
show ProjectSettingAccessLevel
x)))) (ProjectSettingAccessLevel -> Maybe GitLabParam)
-> Maybe ProjectSettingAccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_snippets_access_level EditProjectAttrs
filters,
      (\SquashOption
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"squash_option", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (SquashOption -> [Char]
forall a. Show a => a -> [Char]
show SquashOption
x)))) (SquashOption -> Maybe GitLabParam)
-> Maybe SquashOption -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe SquashOption
project_edit_squash_option EditProjectAttrs
filters,
      (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"suggestion_commit_message", 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
=<< EditProjectAttrs -> Maybe Text
project_edit_suggestion_commit_message EditProjectAttrs
filters,
      (\Visibility
x -> 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
x)))) (Visibility -> Maybe GitLabParam)
-> Maybe Visibility -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe Visibility
project_edit_visibility EditProjectAttrs
filters,
      (\ProjectSettingAccessLevel
x -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"wiki_access_level", Text -> Maybe ByteString
textToBS ([Char] -> Text
T.pack (ProjectSettingAccessLevel -> [Char]
forall a. Show a => a -> [Char]
show ProjectSettingAccessLevel
x)))) (ProjectSettingAccessLevel -> Maybe GitLabParam)
-> Maybe ProjectSettingAccessLevel -> Maybe GitLabParam
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_wiki_access_level EditProjectAttrs
filters,
      (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"issues_template", 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
=<< EditProjectAttrs -> Maybe Text
project_edit_issues_template EditProjectAttrs
filters,
      (\Text
t -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"merge_requests_template", 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
=<< EditProjectAttrs -> Maybe Text
project_edit_merge_requests_template EditProjectAttrs
filters,
      (\Bool
b -> GitLabParam -> Maybe GitLabParam
forall a. a -> Maybe a
Just (ByteString
"keep_latest_artifact", 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
=<< EditProjectAttrs -> Maybe Bool
project_edit_keep_latest_artifact EditProjectAttrs
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 for updating when editing a project with the
-- 'editProject' functions.
data EditProjectAttrs = EditProjectAttrs
  { -- | Set whether or not merge requests can be merged with skipped jobs.
    EditProjectAttrs -> Maybe Bool
project_edit_allow_merge_on_skipped_pipeline :: Maybe Bool,
    -- | One of disabled, private or enabled.
    EditProjectAttrs -> Maybe Text
project_edit_analytics_access_level :: Maybe Text,
    -- | How many approvers should approve merge request by default.
    EditProjectAttrs -> Maybe Int
project_edit_approvals_before_merge :: Maybe Int,
    -- | Auto-cancel pending pipelines.
    EditProjectAttrs -> Maybe EnabledDisabled
project_edit_auto_cancel_pending_pipelines :: Maybe EnabledDisabled,
    -- | Auto Deploy strategy (continuous, manual, or timed_incremental).
    EditProjectAttrs -> Maybe AutoDeployStrategy
project_edit_auto_devops_deploy_strategy :: Maybe AutoDeployStrategy,
    -- | Enable Auto DevOps for this project.
    EditProjectAttrs -> Maybe Bool
project_edit_auto_devops_enabled :: Maybe Bool,
    -- | Set whether auto-closing referenced issues on default branch.
    EditProjectAttrs -> Maybe Bool
project_edit_autoclose_referenced_issues :: Maybe Bool,
    -- | Test coverage parsing.
    EditProjectAttrs -> Maybe Text
project_edit_build_coverage_regex :: Maybe Text,
    -- | The Git strategy. Defaults to fetch.
    EditProjectAttrs -> Maybe GitStrategy
project_edit_build_git_strategy :: Maybe GitStrategy,
    -- | The maximum amount of time, in seconds, that a job can run.
    EditProjectAttrs -> Maybe Int
project_edit_build_timeout :: Maybe Int,
    -- | One of disabled, private, or enabled.
    EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_builds_access_level :: Maybe ProjectSettingAccessLevel,
    -- | The path to CI configuration file.
    EditProjectAttrs -> Maybe Text
project_edit_ci_config_path :: Maybe Text,
    -- | Default number of revisions for shallow cloning.
    EditProjectAttrs -> Maybe Int
project_edit_ci_default_git_depth :: Maybe Int,
    -- | When a new deployment job starts, skip older deployment jobs that are still pending.
    EditProjectAttrs -> Maybe Bool
project_edit_ci_forward_deployment_enabled :: Maybe Bool,
    -- | Set visibility of container registry, for this project, to one of disabled, private or enabled.
    EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_container_registry_access_level :: Maybe ProjectSettingAccessLevel,
    -- | The default branch name.
    EditProjectAttrs -> Maybe Text
project_edit_default_branch :: Maybe Text,
    -- | Short project description.
    EditProjectAttrs -> Maybe Text
project_edit_description :: Maybe Text,
    -- | Disable email notifications.
    EditProjectAttrs -> Maybe Bool
project_edit_emails_disabled :: Maybe Bool,
    -- | The classification label for the project.
    EditProjectAttrs -> Maybe Text
project_edit_external_authorization_classification_label :: Maybe Text,
    -- | One of disabled, private, or enabled.
    EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_forking_access_level :: Maybe ProjectSettingAccessLevel,
    -- | The ID or URL-encoded path of the project.
    EditProjectAttrs -> Int
project_edit_id :: Int,
    -- | URL to import repository from.
    EditProjectAttrs -> Maybe Text
project_edit_import_url :: Maybe Text,
    -- | One of disabled, private, or enabled.
    EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_issues_access_level :: Maybe ProjectSettingAccessLevel,
    -- | Enable LFS.
    EditProjectAttrs -> Maybe Bool
project_edit_lfs_enabled :: Maybe Bool,
    -- | Set the merge method used.
    EditProjectAttrs -> Maybe MergeMethod
project_edit_merge_method :: Maybe MergeMethod,
    -- | One of disabled, private, or enabled.
    EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_merge_requests_access_level :: Maybe ProjectSettingAccessLevel,
    -- | Pull mirror overwrites diverged branches.
    EditProjectAttrs -> Maybe Bool
project_edit_mirror_overwrites_diverged_branches :: Maybe Bool,
    -- | Pull mirroring triggers builds.
    EditProjectAttrs -> Maybe Bool
project_edit_mirror_trigger_builds :: Maybe Bool,
    -- | User responsible for all the activity surrounding a pull mirror event. (admins only)
    EditProjectAttrs -> Maybe Int
project_edit_mirror_user_id :: Maybe Int,
    -- | Enables pull mirroring in a project.
    EditProjectAttrs -> Maybe Bool
project_edit_mirror :: Maybe Bool,
    -- | The name of the project.
    EditProjectAttrs -> Maybe Text
project_edit_name :: Maybe Text,
    -- | One of disabled, private, or enabled.
    EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_operations_access_level :: Maybe ProjectSettingAccessLevel,
    -- | Set whether merge requests can only be merged when all the discussions are resolved.
    EditProjectAttrs -> Maybe Bool
project_edit_only_allow_merge_if_all_discussions_are_resolved :: Maybe Bool,
    -- | Set whether merge requests can only be merged with successful jobs.
    EditProjectAttrs -> Maybe Bool
project_edit_only_allow_merge_if_pipeline_succeeds :: Maybe Bool,
    -- | Only mirror protected branches.
    EditProjectAttrs -> Maybe Bool
project_edit_only_mirror_protected_branches :: Maybe Bool,
    -- | Enable or disable packages repository feature.
    EditProjectAttrs -> Maybe Bool
project_edit_packages_enabled :: Maybe Bool,
    -- | One of disabled, private, enabled, or public.
    EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_pages_access_level :: Maybe ProjectSettingAccessLevel,
    -- | One of disabled, private, enabled or public.
    EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_requirements_access_level :: Maybe ProjectSettingAccessLevel,
    -- | Allow only maintainers to pass user-defined variables when triggering a pipeline. For example when the pipeline is triggered in the UI, with the API, or by a trigger token.
    EditProjectAttrs -> Maybe Bool
project_edit_restrict_user_defined_variables :: Maybe Bool,
    -- | Custom repository name for the project. By default generated based on name.
    EditProjectAttrs -> Maybe Text
project_edit_path :: Maybe Text,
    -- | If true, jobs can be viewed by non-project members.
    EditProjectAttrs -> Maybe Bool
project_edit_public_builds :: Maybe Bool,
    -- | Enable Delete source branch option by default for all new merge requests.
    EditProjectAttrs -> Maybe Bool
project_edit_remove_source_branch_after_merge :: Maybe Bool,
    -- | One of disabled, private, or enabled.
    EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_repository_access_level :: Maybe ProjectSettingAccessLevel,
    -- | Which storage shard the repository is on. (admins only)
    EditProjectAttrs -> Maybe Text
project_edit_repository_storage :: Maybe Text,
    -- | Allow users to request member access.
    EditProjectAttrs -> Maybe Bool
project_edit_request_access_enabled :: Maybe Bool,
    -- | Automatically resolve merge request diffs discussions on lines changed with a push.
    EditProjectAttrs -> Maybe Bool
project_edit_resolve_outdated_diff_discussions :: Maybe Bool,
    -- | Enable or disable Service Desk feature.
    EditProjectAttrs -> Maybe Bool
project_edit_service_desk_enabled :: Maybe Bool,
    -- | Enable shared runners for this project.
    EditProjectAttrs -> Maybe Bool
project_edit_shared_runners_enabled :: Maybe Bool,
    -- | Show default award emojis.
    EditProjectAttrs -> Maybe Bool
project_edit_show_default_award_emojis :: Maybe Bool,
    -- | One of disabled, private, or enabled.
    EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_snippets_access_level :: Maybe ProjectSettingAccessLevel,
    -- | One of never, always, default_on, or default_off.
    EditProjectAttrs -> Maybe SquashOption
project_edit_squash_option :: Maybe SquashOption,
    -- | The commit message used to apply merge request suggestions.
    EditProjectAttrs -> Maybe Text
project_edit_suggestion_commit_message :: Maybe Text,
    EditProjectAttrs -> Maybe Visibility
project_edit_visibility :: Maybe Visibility,
    -- | One of disabled, private, or enabled.
    EditProjectAttrs -> Maybe ProjectSettingAccessLevel
project_edit_wiki_access_level :: Maybe ProjectSettingAccessLevel,
    -- | Default description for Issues. Description is parsed with GitLab Flavored Markdown. See Templates for issues and merge requests.
    EditProjectAttrs -> Maybe Text
project_edit_issues_template :: Maybe Text,
    -- | Default description for Merge Requests. Description is parsed with GitLab Flavored Markdown.
    EditProjectAttrs -> Maybe Text
project_edit_merge_requests_template :: Maybe Text,
    -- | Disable or enable the ability to keep the latest artifact for this project.
    EditProjectAttrs -> Maybe Bool
project_edit_keep_latest_artifact :: Maybe Bool
  }
  deriving ((forall x. EditProjectAttrs -> Rep EditProjectAttrs x)
-> (forall x. Rep EditProjectAttrs x -> EditProjectAttrs)
-> Generic EditProjectAttrs
forall x. Rep EditProjectAttrs x -> EditProjectAttrs
forall x. EditProjectAttrs -> Rep EditProjectAttrs x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep EditProjectAttrs x -> EditProjectAttrs
$cfrom :: forall x. EditProjectAttrs -> Rep EditProjectAttrs x
Generic, Int -> EditProjectAttrs -> [Char] -> [Char]
[EditProjectAttrs] -> [Char] -> [Char]
EditProjectAttrs -> [Char]
(Int -> EditProjectAttrs -> [Char] -> [Char])
-> (EditProjectAttrs -> [Char])
-> ([EditProjectAttrs] -> [Char] -> [Char])
-> Show EditProjectAttrs
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
showList :: [EditProjectAttrs] -> [Char] -> [Char]
$cshowList :: [EditProjectAttrs] -> [Char] -> [Char]
show :: EditProjectAttrs -> [Char]
$cshow :: EditProjectAttrs -> [Char]
showsPrec :: Int -> EditProjectAttrs -> [Char] -> [Char]
$cshowsPrec :: Int -> EditProjectAttrs -> [Char] -> [Char]
Show, EditProjectAttrs -> EditProjectAttrs -> Bool
(EditProjectAttrs -> EditProjectAttrs -> Bool)
-> (EditProjectAttrs -> EditProjectAttrs -> Bool)
-> Eq EditProjectAttrs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EditProjectAttrs -> EditProjectAttrs -> Bool
$c/= :: EditProjectAttrs -> EditProjectAttrs -> Bool
== :: EditProjectAttrs -> EditProjectAttrs -> Bool
$c== :: EditProjectAttrs -> EditProjectAttrs -> Bool
Eq)

-- | Is auto-cancel pending pipelines enabled or disabled
data EnabledDisabled
  = Enabled
  | Disabled
  deriving (EnabledDisabled -> EnabledDisabled -> Bool
(EnabledDisabled -> EnabledDisabled -> Bool)
-> (EnabledDisabled -> EnabledDisabled -> Bool)
-> Eq EnabledDisabled
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnabledDisabled -> EnabledDisabled -> Bool
$c/= :: EnabledDisabled -> EnabledDisabled -> Bool
== :: EnabledDisabled -> EnabledDisabled -> Bool
$c== :: EnabledDisabled -> EnabledDisabled -> Bool
Eq)

instance Show EnabledDisabled where
  show :: EnabledDisabled -> [Char]
show EnabledDisabled
Enabled = [Char]
"enabled"
  show EnabledDisabled
Disabled = [Char]
"disabled"

-- | Auto Deploy strategy: continuous, manual, or timed_incremental,
-- for the 'editProject' functions
data AutoDeployStrategy
  = Continuous
  | Manual
  | TimedIncremental
  deriving (AutoDeployStrategy -> AutoDeployStrategy -> Bool
(AutoDeployStrategy -> AutoDeployStrategy -> Bool)
-> (AutoDeployStrategy -> AutoDeployStrategy -> Bool)
-> Eq AutoDeployStrategy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AutoDeployStrategy -> AutoDeployStrategy -> Bool
$c/= :: AutoDeployStrategy -> AutoDeployStrategy -> Bool
== :: AutoDeployStrategy -> AutoDeployStrategy -> Bool
$c== :: AutoDeployStrategy -> AutoDeployStrategy -> Bool
Eq)

instance Show AutoDeployStrategy where
  show :: AutoDeployStrategy -> [Char]
show AutoDeployStrategy
Continuous = [Char]
"continuous"
  show AutoDeployStrategy
Manual = [Char]
"manual"
  show AutoDeployStrategy
TimedIncremental = [Char]
"timed_incremental"

-- | The Git strategy, defaults to fetch, for the 'editProject' functions
data GitStrategy
  = Clone
  | Fetch
  | None
  deriving (GitStrategy -> GitStrategy -> Bool
(GitStrategy -> GitStrategy -> Bool)
-> (GitStrategy -> GitStrategy -> Bool) -> Eq GitStrategy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GitStrategy -> GitStrategy -> Bool
$c/= :: GitStrategy -> GitStrategy -> Bool
== :: GitStrategy -> GitStrategy -> Bool
$c== :: GitStrategy -> GitStrategy -> Bool
Eq)

instance Show GitStrategy where
  show :: GitStrategy -> [Char]
show GitStrategy
Clone = [Char]
"clone"
  show GitStrategy
Fetch = [Char]
"fetch"
  show GitStrategy
None = [Char]
"none"

-- | The project access level setting, for the 'editProject' functions
data ProjectSettingAccessLevel
  = DisabledAccess
  | PrivateAccess
  | EnabledAccess
  | PublicAccess
  deriving (ProjectSettingAccessLevel -> ProjectSettingAccessLevel -> Bool
(ProjectSettingAccessLevel -> ProjectSettingAccessLevel -> Bool)
-> (ProjectSettingAccessLevel -> ProjectSettingAccessLevel -> Bool)
-> Eq ProjectSettingAccessLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProjectSettingAccessLevel -> ProjectSettingAccessLevel -> Bool
$c/= :: ProjectSettingAccessLevel -> ProjectSettingAccessLevel -> Bool
== :: ProjectSettingAccessLevel -> ProjectSettingAccessLevel -> Bool
$c== :: ProjectSettingAccessLevel -> ProjectSettingAccessLevel -> Bool
Eq)

instance Show ProjectSettingAccessLevel where
  show :: ProjectSettingAccessLevel -> [Char]
show ProjectSettingAccessLevel
DisabledAccess = [Char]
"disabled"
  show ProjectSettingAccessLevel
PrivateAccess = [Char]
"private"
  show ProjectSettingAccessLevel
EnabledAccess = [Char]
"enabled"
  show ProjectSettingAccessLevel
PublicAccess = [Char]
"public"

-- | The project git merge method, for the 'editProject' functions
data MergeMethod
  = Merge
  | RebaseMerge
  | FF
  deriving (MergeMethod -> MergeMethod -> Bool
(MergeMethod -> MergeMethod -> Bool)
-> (MergeMethod -> MergeMethod -> Bool) -> Eq MergeMethod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MergeMethod -> MergeMethod -> Bool
$c/= :: MergeMethod -> MergeMethod -> Bool
== :: MergeMethod -> MergeMethod -> Bool
$c== :: MergeMethod -> MergeMethod -> Bool
Eq)

instance Show MergeMethod where
  show :: MergeMethod -> [Char]
show MergeMethod
Merge = [Char]
"merge"
  show MergeMethod
RebaseMerge = [Char]
"rebase_merge"
  show MergeMethod
FF = [Char]
"ff"

-- | The project git merge squash option, for the 'editProject' functions
data SquashOption
  = NeverSquash
  | AlwaysSquash
  | DefaultOnSquash
  | DefaultOffSquash
  deriving (SquashOption -> SquashOption -> Bool
(SquashOption -> SquashOption -> Bool)
-> (SquashOption -> SquashOption -> Bool) -> Eq SquashOption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SquashOption -> SquashOption -> Bool
$c/= :: SquashOption -> SquashOption -> Bool
== :: SquashOption -> SquashOption -> Bool
$c== :: SquashOption -> SquashOption -> Bool
Eq)

instance Show SquashOption where
  show :: SquashOption -> [Char]
show SquashOption
NeverSquash = [Char]
"never"
  show SquashOption
AlwaysSquash = [Char]
"always"
  show SquashOption
DefaultOnSquash = [Char]
"default_on"
  show SquashOption
DefaultOffSquash = [Char]
"default_off"