Product.hs

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE ImportQualifiedPost #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# OPTIONS_GHC -fno-warn-name-shadowing #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- |
-- Module      : Gogol.AppsActivity.Internal.Product
-- Copyright   : (c) 2015-2025 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+gogol@gmail.com>
--               Toni Cebrián <toni@tonicebrian.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Gogol.AppsActivity.Internal.Product
  ( -- * Activity
    Activity (..),
    newActivity,

    -- * Event
    Event (..),
    newEvent,

    -- * ListActivitiesResponse
    ListActivitiesResponse (..),
    newListActivitiesResponse,

    -- * Move
    Move (..),
    newMove,

    -- * Parent
    Parent (..),
    newParent,

    -- * Permission
    Permission (..),
    newPermission,

    -- * PermissionChange
    PermissionChange (..),
    newPermissionChange,

    -- * Photo
    Photo (..),
    newPhoto,

    -- * Rename
    Rename (..),
    newRename,

    -- * Target
    Target (..),
    newTarget,

    -- * User
    User (..),
    newUser,
  )
where

import Gogol.AppsActivity.Internal.Sum
import Gogol.Prelude qualified as Core

-- | An Activity resource is a combined view of multiple events. An activity has a list of individual events and a combined view of the common fields among all events.
--
-- /See:/ 'newActivity' smart constructor.
data Activity = Activity
  { -- | The fields common to all of the singleEvents that make up the Activity.
    combinedEvent :: (Core.Maybe Event),
    -- | A list of all the Events that make up the Activity.
    singleEvents :: (Core.Maybe [Event])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Activity' with the minimum fields required to make a request.
newActivity ::
  Activity
newActivity =
  Activity
    { combinedEvent = Core.Nothing,
      singleEvents = Core.Nothing
    }

instance Core.FromJSON Activity where
  parseJSON =
    Core.withObject
      "Activity"
      ( \o ->
          Activity
            Core.<$> (o Core..:? "combinedEvent")
            Core.<*> (o Core..:? "singleEvents")
      )

instance Core.ToJSON Activity where
  toJSON Activity {..} =
    Core.object
      ( Core.catMaybes
          [ ("combinedEvent" Core..=) Core.<$> combinedEvent,
            ("singleEvents" Core..=) Core.<$> singleEvents
          ]
      )

-- | Represents the changes associated with an action taken by a user.
--
-- /See:/ 'newEvent' smart constructor.
data Event = Event
  { -- | Additional event types. Some events may have multiple types when multiple actions are part of a single event. For example, creating a document, renaming it, and sharing it may be part of a single file-creation event.
    additionalEventTypes :: (Core.Maybe [Event_AdditionalEventTypesItem]),
    -- | The time at which the event occurred formatted as Unix time in milliseconds.
    eventTimeMillis :: (Core.Maybe Core.Word64),
    -- | Whether this event is caused by a user being deleted.
    fromUserDeletion :: (Core.Maybe Core.Bool),
    -- | Extra information for move type events, such as changes in an object\'s parents.
    move :: (Core.Maybe Move),
    -- | Extra information for permissionChange type events, such as the user or group the new permission applies to.
    permissionChanges :: (Core.Maybe [PermissionChange]),
    -- | The main type of event that occurred.
    primaryEventType :: (Core.Maybe Event_PrimaryEventType),
    -- | Extra information for rename type events, such as the old and new names.
    rename :: (Core.Maybe Rename),
    -- | Information specific to the Target object modified by the event.
    target :: (Core.Maybe Target),
    -- | Represents the user responsible for the event.
    user :: (Core.Maybe User)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Event' with the minimum fields required to make a request.
newEvent ::
  Event
newEvent =
  Event
    { additionalEventTypes = Core.Nothing,
      eventTimeMillis = Core.Nothing,
      fromUserDeletion = Core.Nothing,
      move = Core.Nothing,
      permissionChanges = Core.Nothing,
      primaryEventType = Core.Nothing,
      rename = Core.Nothing,
      target = Core.Nothing,
      user = Core.Nothing
    }

instance Core.FromJSON Event where
  parseJSON =
    Core.withObject
      "Event"
      ( \o ->
          Event
            Core.<$> (o Core..:? "additionalEventTypes")
            Core.<*> (o Core..:? "eventTimeMillis" Core.<&> Core.fmap Core.fromAsText)
            Core.<*> (o Core..:? "fromUserDeletion")
            Core.<*> (o Core..:? "move")
            Core.<*> (o Core..:? "permissionChanges")
            Core.<*> (o Core..:? "primaryEventType")
            Core.<*> (o Core..:? "rename")
            Core.<*> (o Core..:? "target")
            Core.<*> (o Core..:? "user")
      )

instance Core.ToJSON Event where
  toJSON Event {..} =
    Core.object
      ( Core.catMaybes
          [ ("additionalEventTypes" Core..=) Core.<$> additionalEventTypes,
            ("eventTimeMillis" Core..=)
              Core.. Core.AsText
              Core.<$> eventTimeMillis,
            ("fromUserDeletion" Core..=) Core.<$> fromUserDeletion,
            ("move" Core..=) Core.<$> move,
            ("permissionChanges" Core..=) Core.<$> permissionChanges,
            ("primaryEventType" Core..=) Core.<$> primaryEventType,
            ("rename" Core..=) Core.<$> rename,
            ("target" Core..=) Core.<$> target,
            ("user" Core..=) Core.<$> user
          ]
      )

-- | The response from the list request. Contains a list of activities and a token to retrieve the next page of results.
--
-- /See:/ 'newListActivitiesResponse' smart constructor.
data ListActivitiesResponse = ListActivitiesResponse
  { -- | List of activities.
    activities :: (Core.Maybe [Activity]),
    -- | Token for the next page of results.
    nextPageToken :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'ListActivitiesResponse' with the minimum fields required to make a request.
newListActivitiesResponse ::
  ListActivitiesResponse
newListActivitiesResponse =
  ListActivitiesResponse
    { activities = Core.Nothing,
      nextPageToken = Core.Nothing
    }

instance Core.FromJSON ListActivitiesResponse where
  parseJSON =
    Core.withObject
      "ListActivitiesResponse"
      ( \o ->
          ListActivitiesResponse
            Core.<$> (o Core..:? "activities")
            Core.<*> (o Core..:? "nextPageToken")
      )

instance Core.ToJSON ListActivitiesResponse where
  toJSON ListActivitiesResponse {..} =
    Core.object
      ( Core.catMaybes
          [ ("activities" Core..=) Core.<$> activities,
            ("nextPageToken" Core..=) Core.<$> nextPageToken
          ]
      )

-- | Contains information about changes in an object\'s parents as a result of a move type event.
--
-- /See:/ 'newMove' smart constructor.
data Move = Move
  { -- | The added parent(s).
    addedParents :: (Core.Maybe [Parent]),
    -- | The removed parent(s).
    removedParents :: (Core.Maybe [Parent])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Move' with the minimum fields required to make a request.
newMove ::
  Move
newMove =
  Move {addedParents = Core.Nothing, removedParents = Core.Nothing}

instance Core.FromJSON Move where
  parseJSON =
    Core.withObject
      "Move"
      ( \o ->
          Move
            Core.<$> (o Core..:? "addedParents")
            Core.<*> (o Core..:? "removedParents")
      )

instance Core.ToJSON Move where
  toJSON Move {..} =
    Core.object
      ( Core.catMaybes
          [ ("addedParents" Core..=) Core.<$> addedParents,
            ("removedParents" Core..=) Core.<$> removedParents
          ]
      )

-- | Contains information about a parent object. For example, a folder in Drive is a parent for all files within it.
--
-- /See:/ 'newParent' smart constructor.
data Parent = Parent
  { -- | The parent\'s ID.
    id :: (Core.Maybe Core.Text),
    -- | Whether this is the root folder.
    isRoot :: (Core.Maybe Core.Bool),
    -- | The parent\'s title.
    title :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Parent' with the minimum fields required to make a request.
newParent ::
  Parent
newParent =
  Parent
    { id = Core.Nothing,
      isRoot = Core.Nothing,
      title = Core.Nothing
    }

instance Core.FromJSON Parent where
  parseJSON =
    Core.withObject
      "Parent"
      ( \o ->
          Parent
            Core.<$> (o Core..:? "id")
            Core.<*> (o Core..:? "isRoot")
            Core.<*> (o Core..:? "title")
      )

instance Core.ToJSON Parent where
  toJSON Parent {..} =
    Core.object
      ( Core.catMaybes
          [ ("id" Core..=) Core.<$> id,
            ("isRoot" Core..=) Core.<$> isRoot,
            ("title" Core..=) Core.<$> title
          ]
      )

-- | Contains information about the permissions and type of access allowed with regards to a Google Drive object. This is a subset of the fields contained in a corresponding Drive Permissions object.
--
-- /See:/ 'newPermission' smart constructor.
data Permission = Permission
  { -- | The name of the user or group the permission applies to.
    name :: (Core.Maybe Core.Text),
    -- | The ID for this permission. Corresponds to the Drive API\'s permission ID returned as part of the Drive Permissions resource.
    permissionId :: (Core.Maybe Core.Text),
    -- | Indicates the Google Drive permissions role. The role determines a user\'s ability to read, write, or comment on the file.
    role' :: (Core.Maybe Permission_Role),
    -- | Indicates how widely permissions are granted.
    type' :: (Core.Maybe Permission_Type),
    -- | The user\'s information if the type is USER.
    user :: (Core.Maybe User),
    -- | Whether the permission requires a link to the file.
    withLink :: (Core.Maybe Core.Bool)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Permission' with the minimum fields required to make a request.
newPermission ::
  Permission
newPermission =
  Permission
    { name = Core.Nothing,
      permissionId = Core.Nothing,
      role' = Core.Nothing,
      type' = Core.Nothing,
      user = Core.Nothing,
      withLink = Core.Nothing
    }

instance Core.FromJSON Permission where
  parseJSON =
    Core.withObject
      "Permission"
      ( \o ->
          Permission
            Core.<$> (o Core..:? "name")
            Core.<*> (o Core..:? "permissionId")
            Core.<*> (o Core..:? "role")
            Core.<*> (o Core..:? "type")
            Core.<*> (o Core..:? "user")
            Core.<*> (o Core..:? "withLink")
      )

instance Core.ToJSON Permission where
  toJSON Permission {..} =
    Core.object
      ( Core.catMaybes
          [ ("name" Core..=) Core.<$> name,
            ("permissionId" Core..=) Core.<$> permissionId,
            ("role" Core..=) Core.<$> role',
            ("type" Core..=) Core.<$> type',
            ("user" Core..=) Core.<$> user,
            ("withLink" Core..=) Core.<$> withLink
          ]
      )

-- | Contains information about a Drive object\'s permissions that changed as a result of a permissionChange type event.
--
-- /See:/ 'newPermissionChange' smart constructor.
data PermissionChange = PermissionChange
  { -- | Lists all Permission objects added.
    addedPermissions :: (Core.Maybe [Permission]),
    -- | Lists all Permission objects removed.
    removedPermissions :: (Core.Maybe [Permission])
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'PermissionChange' with the minimum fields required to make a request.
newPermissionChange ::
  PermissionChange
newPermissionChange =
  PermissionChange
    { addedPermissions = Core.Nothing,
      removedPermissions = Core.Nothing
    }

instance Core.FromJSON PermissionChange where
  parseJSON =
    Core.withObject
      "PermissionChange"
      ( \o ->
          PermissionChange
            Core.<$> (o Core..:? "addedPermissions")
            Core.<*> (o Core..:? "removedPermissions")
      )

instance Core.ToJSON PermissionChange where
  toJSON PermissionChange {..} =
    Core.object
      ( Core.catMaybes
          [ ("addedPermissions" Core..=) Core.<$> addedPermissions,
            ("removedPermissions" Core..=) Core.<$> removedPermissions
          ]
      )

-- | Photo information for a user.
--
-- /See:/ 'newPhoto' smart constructor.
newtype Photo = Photo
  { -- | The URL of the photo.
    url :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Photo' with the minimum fields required to make a request.
newPhoto ::
  Photo
newPhoto = Photo {url = Core.Nothing}

instance Core.FromJSON Photo where
  parseJSON =
    Core.withObject
      "Photo"
      (\o -> Photo Core.<$> (o Core..:? "url"))

instance Core.ToJSON Photo where
  toJSON Photo {..} =
    Core.object (Core.catMaybes [("url" Core..=) Core.<$> url])

-- | Contains information about a renametype event.
--
-- /See:/ 'newRename' smart constructor.
data Rename = Rename
  { -- | The new title.
    newTitle' :: (Core.Maybe Core.Text),
    -- | The old title.
    oldTitle :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Rename' with the minimum fields required to make a request.
newRename ::
  Rename
newRename =
  Rename {newTitle' = Core.Nothing, oldTitle = Core.Nothing}

instance Core.FromJSON Rename where
  parseJSON =
    Core.withObject
      "Rename"
      ( \o ->
          Rename
            Core.<$> (o Core..:? "newTitle")
            Core.<*> (o Core..:? "oldTitle")
      )

instance Core.ToJSON Rename where
  toJSON Rename {..} =
    Core.object
      ( Core.catMaybes
          [ ("newTitle" Core..=) Core.<$> newTitle',
            ("oldTitle" Core..=) Core.<$> oldTitle
          ]
      )

-- | Information about the object modified by the event.
--
-- /See:/ 'newTarget' smart constructor.
data Target = Target
  { -- | The ID of the target. For example, in Google Drive, this is the file or folder ID.
    id :: (Core.Maybe Core.Text),
    -- | The MIME type of the target.
    mimeType :: (Core.Maybe Core.Text),
    -- | The name of the target. For example, in Google Drive, this is the title of the file.
    name :: (Core.Maybe Core.Text)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'Target' with the minimum fields required to make a request.
newTarget ::
  Target
newTarget =
  Target
    { id = Core.Nothing,
      mimeType = Core.Nothing,
      name = Core.Nothing
    }

instance Core.FromJSON Target where
  parseJSON =
    Core.withObject
      "Target"
      ( \o ->
          Target
            Core.<$> (o Core..:? "id")
            Core.<*> (o Core..:? "mimeType")
            Core.<*> (o Core..:? "name")
      )

instance Core.ToJSON Target where
  toJSON Target {..} =
    Core.object
      ( Core.catMaybes
          [ ("id" Core..=) Core.<$> id,
            ("mimeType" Core..=) Core.<$> mimeType,
            ("name" Core..=) Core.<$> name
          ]
      )

-- | A representation of a user.
--
-- /See:/ 'newUser' smart constructor.
data User = User
  { -- | A boolean which indicates whether the specified User was deleted. If true, name, photo and permission_id will be omitted.
    isDeleted :: (Core.Maybe Core.Bool),
    -- | Whether the user is the authenticated user.
    isMe :: (Core.Maybe Core.Bool),
    -- | The displayable name of the user.
    name :: (Core.Maybe Core.Text),
    -- | The permission ID associated with this user. Equivalent to the Drive API\'s permission ID for this user, returned as part of the Drive Permissions resource.
    permissionId :: (Core.Maybe Core.Text),
    -- | The profile photo of the user. Not present if the user has no profile photo.
    photo :: (Core.Maybe Photo)
  }
  deriving (Core.Eq, Core.Show, Core.Generic)

-- | Creates a value of 'User' with the minimum fields required to make a request.
newUser ::
  User
newUser =
  User
    { isDeleted = Core.Nothing,
      isMe = Core.Nothing,
      name = Core.Nothing,
      permissionId = Core.Nothing,
      photo = Core.Nothing
    }

instance Core.FromJSON User where
  parseJSON =
    Core.withObject
      "User"
      ( \o ->
          User
            Core.<$> (o Core..:? "isDeleted")
            Core.<*> (o Core..:? "isMe")
            Core.<*> (o Core..:? "name")
            Core.<*> (o Core..:? "permissionId")
            Core.<*> (o Core..:? "photo")
      )

instance Core.ToJSON User where
  toJSON User {..} =
    Core.object
      ( Core.catMaybes
          [ ("isDeleted" Core..=) Core.<$> isDeleted,
            ("isMe" Core..=) Core.<$> isMe,
            ("name" Core..=) Core.<$> name,
            ("permissionId" Core..=) Core.<$> permissionId,
            ("photo" Core..=) Core.<$> photo
          ]
      )