Dalet Galaxy five API

Dalet Galaxy five exposes a GraphQL-based web service that provides an interface into Dalet operations and data.

Getting Started

The application server WebService3 publishes this GraphQL API and is available for deployment from Dalet Galaxy Remote Admin inventory. It comes with configurable SSL options and endpoint port.

The link to the WebService3 server's welcome web page is available from the Settings page in the application server in Remote Admin inventory. The following resources are available on the welcome web page of WebService3:

1. The GraphQL endpoint of the GraphQL API.
2. The GraphiQL Web client. This interactive GraphQL client allows you to use the web service and activate its queries, mutations and subscriptions, via a web browser. It also includes built-in documentation for each operation describing methods’ inputs and outputs and other relevant information.
3. A user guide PDF document.

To get familiar with GraphQL technology, you can start by reading the following documentation:

Learn GraphQL

Then you can use the GraphiQL Web client to experiment with GraphQL operations against your Dalet site. Note that any operation executed with this web client will be performed against your Dalet site, so you can retrieve real data and update it.

Security

SSL

WebService3 provides the option to access the service via https and to establish a secure connection with standard SSL certificates encryption.
This option is available when configuring the server, and requires:

• Keystore file
• Key Password
• Keystore Password

Authentication

To authorize, use this code:

mutation LoginToDalet {
        login (
            input: {
                username: "MyLogin",
                password: "MyPassword" } ) 
            {
            token
        }
    }

The above command returns JSON structured like this:

{
  "data": {
    "login": {
      "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzUxMiJ9.eyJzdWIiOiJkYWxldF9hZG1pbiIsImV4c
      CI6MTU4MjEzOTEyNCwiaWF0IjoxNTgyMTI0NzI0LCJ1c2VySWQiOiIxIn0.j8p0G0OBcpGELGKRyPqysi
      h0I8wWTqHrvVyk4bNydTUu4jfhTCBOTKdwpSL6haJWXJ3Q_-HloSLtVxuVk-cVOUHVfU74-mKgbKqak7_Foa14AAur9tt
      j61FI-5NlhDLzRzxSp0cWl0FTnfxZNr-EMUjSYxqlz4dWG0scrkQuFgbqPx13-R0GdbkIrtcakO_WOdCzm55_Yga_B_gfTIotL8
      1m9ELQxRdl6aG7CoVpjayW8TmmVrradXkRTMy_g1PXiy7AtIXRUF9y9WNcVON5oCZkvBEgXVRG70HEtgpJ9Mjf7ND8TdeoGHNvg
      VQJiWmY4EObWapRaSb90pw0GErypw"
    }
  }
}

The WebService3 server works with OAuth2 authentication, every operation performed against the service requires a JWT token to be passed in the request. To acquire a token, first perform a login request. The token is valid for 4 hours.

The login mutation does not require previous authentication, while all other operations do.

On providing valid username/password to the login mutation, you will receive a JWT token that you must provide in all future operations.

For regular http requests such as Query and Mutation, you must provide this token in the HTTP header called “Authorization” with the prefix “Bearer “:

Authorization: Bearer eyj0...mTnG

For Subscription over websocket, when connecting, the payload of the “connection_init” message must be a map with at least one key “Authorization” where the value is the JWT token with the prefix “Bearer “:

{ "type": "connection_init", "payload": { "Authorization": "Bearer eyj0...mTnG" } } }

Operations

Assets

Describes operations to create, retrieve, update and delete assets.

query assets

Example: Retrieve all video assets with item code "Ready" and with duration of 50 minutes

query {
  assets(
    input: {
      where: {
        assetTypesWith: { mediaTypes: [VIDEO] }
        metadataSearchMode: ALL_MATCH
        metadata: [
          { field: { name: "Item Code" }, value: "Ready" }
          { field: { name: "Title Duration" }, value: "P0:50:0.000S PAL" }
        ]
      }
    }
  ) {
    assets {
      id
      name
    }
  }
}

Retrieve information about assets matching the supplied filter.
Assets can be filtered by their ids, itemCodes, assetTypesWith, metadata, metadataSerchMode and categories.
The retrieved assets are an intersection of all filter fields.
In order to retrieve an asset, user should have View rights to its primary category.

• Inputs - AssetsInput:

• Outputs - AssetsOutput:

subqueries

Queries to retrieve information about assets from outputs of other operations.

• AssetUsage
  assetMetadataUsage: sub query to retrieve the assets that reference the current asset as metadata
  bundlesUsage: sub query to retrieve the bundle assets that have the current asset listed inside them
  clipsUsage: sub query to retrieve the clip assets that have the current asset as parent
  edlsUsage: sub query to retrieve the EDL assets that have the current asset listed inside them
  groupsUsage: sub query to retrieve the group assets that have the current asset listed inside them
  patternsUsage: sub query to retrieve the pattern assets that have the current asset listed inside them
  storiesUsage: sub query to retrieve the story assets that have the current asset embedded inside them

• BundleAsset
  mediaAssets: sub query to retrieve the media assets listed in the current bundle asset
  trackStackAssets: sub query to retrieve the trackstack assets associated to the current bundle asset
  versionAssets: sub query to retrieve the TXVersion assets associated to the current bundle asset

• Category
  assets: sub query to retrieve assets inside a Category

• GroupAsset
  items: sub query to retrieve items inside a Group

• VideoAsset
  cgToVideoAssociations: sub query to retrieve the CG assets associated to the current asset
  subtitlesToVideoAssociations: sub query to retrieve the subtitles assets associated to the current asset

Example: Retrieve the first five assets that reference the asset with id 17392 as metadata

query {
  assets(input: { where: { ids: [17392] } }) {
    assets {
      id
      usage {
        assetMetadataUsage(input: { select: { first: 5 } }) {
          assets {
            id
            name
            itemCode
            status {
              name
            }
          }
        }
      }
    }
  }
}

subquery assetMetadataUsage

Retrieve the assets that reference the current asset as metadata.
Assets can be filtered by their ids, itemCodes, assetTypesWith, metadata, metadataSerchMode and categories.
The retrieved assets correspond to the supplied filter.
In order to retrieve an asset, user should have View rights to its primary category.

• Inputs - AssetsInput:

• Outputs - AssetsOutput:

Example: Retrieve the first five bundle assets that have asset with id 357560 listed inside them

query {
  assets(input: { where: { ids: [357560] } }) {
    assets {
      id
      usage {
        bundlesUsage(input: { select: { first: 5 } }) {
          assets {
            id
            name
            itemCode
            status {
              name
            }
          }
        }
      }
    }
  }
}

subquery bundlesUsage

Retrieve the bundle assets that have the current asset listed inside them.
Bundle assets can be filtered by their ids, itemCodes, metadata, metadataSerchMode and categories.
The retrieved bundle assets correspond to the supplied filter.
In order to retrieve a bundle asset, user should have View rights to its primary category.

• Inputs - bundleAssetsInput:

• Outputs - AssetsOutput:

Example: Retrieve the first five clip assets that have asset with id 357014 as parent

query {
  assets(input: { where: { ids: [357014] } }) {
    assets {
      id
      usage {
        clipsUsage(input: { select: { first: 5 } }) {
          assets {
            id
            name
            itemCode
            status {
              name
            }
          }
        }
      }
    }
  }
}

subquery clipsUsage

Retrieve the clip assets that have the current asset as parent.
Clip assets can be filtered by their ids, itemCodes, metadata, metadataSerchMode and categories.
The retrieved clip assets correspond to the supplied filter.
In order to retrieve a clip asset, user should have View rights to its primary category.

• Inputs - ClipAssetsInput:

• Outputs - AssetsOutput:

Example: Retrieve the first five EDL assets that have asset with id 356822 listed inside them

query {
  assets(input: { where: { ids: [356822] } }) {
    assets {
      id
      usage {
        edlsUsage(input: { select: { first: 5 } }) {
          assets {
            id
            name
            itemCode
            status {
              name
            }
          }
        }
      }
    }
  }
}

subquery edlsUsage

Retrieve the EDL assets that have the current asset listed inside them.
EDL assets can be filtered by their ids, itemCodes, metadata, metadataSerchMode and categories.
The retrieved EDL assets correspond to the supplied filter.
In order to retrieve an EDL asset, user should have View rights to its primary category.

• Inputs - EDLAssetsInput:

• Outputs - AssetsOutput:

Example: Retrieve the first five group assets that have asset with id 356290 listed inside them

query {
  assets(input: { where: { ids: [356290] } }) {
    assets {
      id
      usage {
        groupsUsage(input: { select: { first: 5 } }) {
          assets {
            id
            name
            itemCode
            status {
              name
            }
          }
        }
      }
    }
  }
}

subquery groupsUsage

Retrieve the group assets that have the current asset listed inside them.
Group assets can be filtered by their ids, itemCodes, metadata, metadataSerchMode and categories.
The retrieved group assets correspond to the supplied filter.
In order to retrieve a group asset, user should have View rights to its primary category.

• Inputs - GroupAssetsInput:

• Outputs - AssetsOutput:

Example: Retrieve the first five pattern assets that have asset with id 357540 listed inside them

query {
  assets(input: { where: { ids: [357540] } }) {
    assets {
      id
      usage {
        patternsUsage(input: { select: { first: 5 } }) {
          assets {
            id
            name
            itemCode
            status {
              name
            }
          }
        }
      }
    }
  }
}

subquery patternsUsage

Retrieve the pattern assets that have the current asset listed inside them.
Pattern assets can be filtered by their ids, itemCodes, metadata, metadataSerchMode and categories.
The retrieved pattern assets correspond to the supplied filter.
In order to retrieve a pattern asset, user should have View rights to its primary category.

• Inputs - patternAssetsInput:

• Outputs - AssetsOutput:

Example: Retrieve the first five story assets that have asset with id 355560 embedded inside them

query {
  assets(input: { where: { ids: [355560] } }) {
    assets {
      id
      usage {
        storiesUsage(input: { select: { first: 5 } }) {
          assets {
            id
            name
            itemCode
            status {
              name
            }
          }
        }
      }
    }
  }
}

subquery storiesUsage

Retrieve the story assets that have the current asset embedded inside them.
Story assets can be filtered by their ids, itemCodes, metadata, metadataSerchMode and categories.
The retrieved story assets correspond to the supplied filter.
In order to retrieve a story asset, user should have View rights to its primary category.

• Inputs - storyAssetsInput:

• Outputs - AssetsOutput:

Example: Retrieve the first five media assets listed in bundle asset with id 355260

query {
  assets(input: { where: { ids: [355260] } }) {
    assets {
      ... on BundleAsset {
        mediaAssets(input: { select: { first: 5 } }) {
          assets {
            id
          }
        }
      }
    }
  }
}

subquery mediaAssets

Retrieve the media assets listed in the current bundle asset.
Media assets can be filtered by their ids, itemCodes, assetTypesWith, metadata, metadataSerchMode and categories.
The retrieved media assets match the supplied filter.
In order to retrieve a media asset, user should have View rights to its primary category.

• Inputs - AssetsInput:

• Outputs - AssetsOutput:

Example: Retrieve the first five track stack assets listed in bundle asset with id 355260

query {
  assets(input: { where: { ids: [355260] } }) {
    assets {
      ... on BundleAsset {
        trackStackAssets(input: { select: { first: 5 } }) {
          assets {
            id
          }
        }
      }
    }
  }
}

subquery trackStackAssets

Retrieve the track stack assets listed in the current bundle asset.
Track stack assets can be filtered by their ids, itemCodes, metadata, metadataSerchMode and categories.
The retrieved track stack assets match the supplied filter.
In order to retrieve a track stack asset, user should have View rights to its primary category.

• Inputs - TrackStackAssetsInput:

• Outputs - AssetsOutput:

Example: Retrieve the first five version assets listed in bundle asset with id 355260

query {
  assets(input: { where: { ids: [355260] } }) {
    assets {
      ... on BundleAsset {
        versionAssets(input: { select: { first: 5 } }) {
          assets {
            id
          }
        }
      }
    }
  }
}

subquery versionAssets

Retrieve the version assets listed in the current bundle asset.
Version assets can be filtered by their ids, itemCodes, metadata, metadataSerchMode and categories.
The retrieved version assets match the supplied filter.
In order to retrieve a version asset, user should have View rights to its primary category.

• Inputs - TxVersionAssetsInput:

• Outputs - AssetsOutput:

Example: Retrieve all video assets from category with id 67

query {
  categories(input: { where: { ids: [67] } }) {
    categories {
      assets(input: { where: { assetTypesWith: { mediaTypes: [VIDEO] } } }) {
        assets {
          id
          name
        }
      }
    }
  }
}

subquery assets

Retrieve information about assets associated to the given category.
Assets can be filtered by their ids, itemCodes, assetTypesWith, metadata and metadataSerchMode.
The retrieved assets match the supplied filter.
In order to retrieve an asset, user should have View rights to its primary category.

• Inputs - AssetsInCategoryInput:

• Outputs - AssetsOutput:

Example: Retrieve the first five items inside group asset with id 356290

query {
  assets(input: { where: { ids: [356290] } }) {
    assets {
      id
      name
      ... on GroupAsset {
        items(input: { select: { first: 5 } }) {
          items {
            id
          }
        }
      }
    }
  }
}

subquery items

Retrieve items contained in the current group asset.
Group items can be filtered by their groupItemIds.
The retrieved group items match the supplied filter.

• Inputs - NestedGroupItemsInput:

• Outputs - NestedGroupItemsOutput:

Example: Retrieve the first five associations for cg asset with id 357767

query {
  assets(input: { where: { ids: [357767] } }) {
    assets {
      ... on VideoAsset {
        cgToVideoAssociations(input: { select: { first: 5 } }) {
          cgToVideoAssociations {
            id
            videoAsset {
              id
            }
            cgAsset {
              id
            }
          }
        }
      }
    }
  }
}

subquery cgToVideoAssociations

Retrieve the CG assets associated to the current asset.
CG assets can be filtered by their ids, itemCodes, metadata, metadataSerchMode and categories.
The retrieved CG assets match the supplied filter.
There can be at most one CG asset per CG channel.
In order to retrieve an asset, user should have View rights to its primary category.

• Inputs - CGToVideoAssociationsInput:

• Outputs - CGToVideoAssociationsOutput:

Example: Retrieve the first five associations for subtitle asset with id 2772

query {
  assets(input: { where: { ids: [2772] } }) {
    assets {
      id
      ... on VideoAsset {
        subtitlesToVideoAssociations(input: { select: { first: 5 } }) {
          subtitlesToVideoAssociations {
            id
            studioChannel {
              id
            }
            videoAsset {
              id
            }
            subtitlesAsset {
              id
            }
          }
        }
      }
    }
  }
}

subquery subtitlesToVideoAssociations

Retrieve the subtitles assets associated to the current asset.
Subtitles assets can be filtered by their ids, itemCodes, metadata, metadataSerchMode and categories.
The retrieved subtitles assets match the supplied filter.
There can be at most one subtitles asset per subtitles channel.
In order to retrieve an asset, user should have View rights to its primary category.

• Inputs - SubtitlesToVideoAssociationsInput:

• Outputs - SubtitlesToVideoAssociationsOutput:

mutation addItemsToGroups

Example: Add 2 asset segments to a group. The first will start at the beginning of the media's duration and will finish after 10:15 minutes, and the second will start 05:00 minutes before the end of the media's duration and will finish at the end of the media's duration

mutation {
  addItemsToGroups(input: { itemsToGroups: { groupId:2002,
  assetSegments: [ { assetId:2000, position: 0, tcOut: "00:10:15", tcOutRelativeToStart: true },
                   { assetId:1986, tcIn:"00:05:00", tcInRelativeToEnd:true } ] } } ) {
    groupItems {
      id
      asset {
        id
      }
    }
  }
}

Add a list of items to a specific group.
Items provided as part of ItemsToGroupInput must not be of type group assets.
In order to add items to group assets, user should have Insert and Remove rights on the category of the group asset and View rights on the category of the asset that he wants to add to the group.
The asset type of the item that is added to the group must correspond with the group channels configuration.

• Inputs - AddItemsToGroupsInput:

• Outputs - AddItemsToGroupsOutput:

mutation copyAsset

Example: Copy different types of information from assets

mutation {
  metadata: copyAsset( input: {
      copyTypes: INHERITABLE_METADATA 
      sourceAssetId: 17392, targetAssetId: 354890
    } ) { 
    updatedAsset {
      id
  } }

  locators: copyAsset( input: {
      copyTypes: INHERITABLE_LOCATORS
      sourceAssetId: 2058, targetAssetId: 356887
    } ) { 
    updatedAsset {
      id
  } }

  genealogy: copyAsset( input: {
      copyTypes: GENEALOGY
      sourceAssetId: 354870, targetAssetId: 356830
    } ) { 
    updatedAsset {
      id
} } }

Copy information from one asset to another.
In order to copy information from one asset to another, user should have View rights on the category of the source asset and Insert and Remove rights on the category of the target asset.

• Inputs - CopyAssetInput:

• Outputs - CopyAssetOutput:

mutation createAudioAssets

Example: Create an audio asset with keyword "API3" and status "Approved" in category with id 0

mutation {
  createAudioAssets(
    input: {
      assets: {
        assetName: "AudioAsset"
        categoryId: "0"
        itemCode: "ITEMCODE"
        status: { name: "Approved" }
        metadata: { field: { name: "Keywords" }, value: "API3" } } } ) {
    assets {
      id
    }
  }
}

Create a list of audio assets with the given parameters.
In order to create an asset, user should have Insert rights on the category.

• Inputs - CreateAudioAssetsInput:

• Outputs - CreateAssetsOutput:

mutation createBundleAssets

Example: Create a bundle asset with status "Approved" in category with id 0 and a specified keep date

mutation {
  createBundleAssets(
    input: {
      assets: {
        assetName: "BundleAsset"
        categoryId: "0"
        status: { name: "Approved" }
        itemCode: "ITEMCODE"
        metadata: {
          field: { name: "Title Keep Date" }, value: "2022-08-12T10:10:10.100" } } } ) {
    assets {
      id
    }
  }
}

Create a list of bundle assets with the given parameters.
In order to create an asset, user should have Insert rights on the category.

• Inputs - CreateBundleAssetsInput:

• Outputs - CreateAssetsOutput:

mutation createCGAssets

Example: Create a CG asset of type with id 1080 in category with id 0 and a specified metadata value

mutation {
  createCGAssets(
    input: {
      assets: {
        assetName: "CG"
        categoryId: "0"
        cgType: { id: "1080" }
        itemCode: "ITEMCODE"
        metadata: { field: { name: "CG Ready" }, value: "Completed" } } } ) {
    assets {
      id
    }
  }
}

Create a list of CG assets with the given parameters.
In order to create an asset, user should have Insert rights on the category.

• Inputs - CreateCGAssetsInput:

• Outputs - CreateAssetsOutput:

mutation createCGToVideoAssociations

Example: Create an association between CG asset with id 356336 and video asset with id 17392

mutation {
  createCGToVideoAssociations(
    input: {
      associations: {
        videoAssetId: 17392
        cgAssetId: 356336
        studioChannelName: "CG"
      }
    }
  ) {
    associations {
      id
    }
  }
}

Create associations between CG assets and video assets.
Creating a CG to video asset association with tcIn matching existing association on same channel will overwrite the CG asset id and tcOut values of the existing association. The association id will not change. There is no limitation of the number of associations per channel for a video asset.
In order to associate a CG asset with a video asset, user should have Insert and Remove rights on the category of the video asset and View rights on the category of the CG asset.

• Inputs - CreateCGToVideoAssociationsInput:

• Outputs - CreateCGToVideoAssociationsOutput:

mutation createClipAssets

Example: Create a clip asset in category with id 0 originated from asset with id 1227

mutation {
  createClipAssets(
    input: {
      assets: {
        assetName: "ClipAsset"
        categoryId: "0"
        parentAssetId: 1227
        tcIn: "00:00", tcOut: "00:10"
        itemCode: "ITEMCODE" } } ) {
    assets {
      id
    }
  }
}

Create a list of clip assets with the given parameters.
In order to create an asset, user should have Insert rights on the category.

• Inputs - CreateClipAssetsInput:

• Outputs - CreateAssetsOutput:

mutation createExtendedAssets

Example: Create an extended asset of type "Archive File" in category with id 0 and a specified metadata value

mutation {
  createExtendedAssets(
    input: {
      assets: {
        assetName: "ExtendedAsset"
        categoryId: "0"
        extendedType: { name: "Archive File" }
        itemCode: "ITEMCODE"
        metadata: { field: { tagName: "TitleAuthor" }, value: "API3" } } } ) {
    assets {
      id
    }
  }
}

Create a list of extended assets with the given parameters.
In order to create an asset, user should have Insert rights on the category.

• Inputs - CreateExtendedAssetsInput:

• Outputs - CreateAssetsOutput:

mutation createGroupAssets

Example: Create a group asset with status "Approved" in category with id 0 and a specified metadata value

mutation {
  createGroupAssets(
    input: {
      assets: {
        assetName: "GroupAsset"
        categoryId: "0"
        status: { name: "Approved" }
        itemCode: "ITEMCODE"
        metadata: {
          field: { name: "Title End Date" }, value: "2022-08-12T10:10:10.100" } } } ) {
    assets {
      id
    }
  }
}

Create a list of group assets with the given parameters.
In order to create an asset, user should have Insert rights on the category.

• Inputs - CreateGroupAssetsInput:

• Outputs - CreateAssetsOutput:

mutation createImageAssets

Example: Create two image assets with different attributes

mutation {
  createImageAssets(
    input: {
      assets: [
        { assetName: "ImageAsset1", categoryId: "0", status: { name: "New" } }
        { assetName: "ImageAsset2", categoryId: "1", itemCode: "ITEMCODE" } ] } ) {
    assets {
      id
    }
  }
}

Create a list of image assets with the given parameters.
In order to create an asset, user should have Insert rights on the category.

• Inputs - CreateImageAssetsInput:

• Outputs - CreateAssetsOutput:

mutation createStoryAssets

Example: Create a story asset with template with id 4, in category with id 0, with the specified metadata

mutation {
  createStoryAssets(
    input: {
      assets: {
        assetName: "StoryAsset"
        categoryId: 0
        storyTemplate: { id: 4 }
        itemCode: "ITEMCODE"
        metadata: { field: { tagName: "TitleSource" }, value: "API3" } } } ) {
    assets {
      id
    }
  }
}

Create a list of story assets with the given parameters.
In order to create an asset, user should have Insert rights on the category.

• Inputs - CreateStoryAssetsInput:

• Outputs - CreateAssetsOutput:

mutation createSubtitlesAssets

Example: Create a subtitles asset of type with id 1004, in category with id 0, with status "Archive"

mutation {
  createSubtitlesAssets(
    input: {
      assets: {
        assetName: "SubtitleAsset"
        categoryId: 0
        subtitlesType: { id: 1004 }
        status: { name: "Archive" }
        itemCode: "ITEMCODE" } } ) {
    assets {
      id
    }
  }
}

Create a list of subtitles assets with the given parameters.
In order to create an asset, user should have Insert rights on the category.

• Inputs - CreateSubtitlesAssetsInput:

Default values: The following depends on the site policy: recordDate, startDate, endDate, killDate, keepDate

• Outputs - CreateAssetsOutput:

mutation createSubtitlesToVideoAssociations

Example: Create an association between subtitles asset with id 1750 and video asset with id 17392

mutation {
  createSubtitlesToVideoAssociations(
    input: {
      associations: {
        videoAssetId: 17392
        subtitlesAssetId: 1750
        studioChannelName: "Subtitle"
      }
    }
  ) {
    associations {
      id
    }
  }
}

Create associations between subtitles assets and video assets.
Creating a subtitles to video association with tcIn matching existing association on same channel will overwrite the subtitles asset id and tcOut values of the existing association. The association id will not change. There is no limitation of the number of associations per channel for a video asset.
In order to associate a subtitles asset with a video asset, user should have Insert and Remove rights on the category of the video asset and View rights on the category of the subtitles asset.

• Inputs - CreateSubtitlesToVideoAssociationsInput:

• Outputs - CreateSubtitlesToVideoAssociationsOutput:

mutation createTrackStackAssets

Example: Create a trackstack asset with template "TrackStackTemplate" in bundle with id 2273, with the specified metadata

mutation {
  createTrackStackAssets(
    input: {
      assets: {
        bundleAssetId: 2273
        assetName: "TrackStackAsset"
        template: { name: "TrackStackTemplate" }
        metadata: { field: { name: "TS Originated From" }, value: "API3" } } } ) {
    assets {
      id
    }
  }
}

Create a list of trackstack assets that are added to a bundle asset.
In order to create a track stack asset, user should have Insert and Remove rights on the category of the Bundle Asset.

• Inputs - CreateTrackStackAssetsInput:

• Outputs - CreateAssetsOutput:

mutation createTxVersionAssets

Example: Create a TXVersion asset in category with id 0, with status "Approved" and the specified metadata

mutation {
  createTxVersionAssets(
    input: {
      assets: {
        assetName: "TXVersionAsset"
        categoryId: 0
        status: { name: "Approved" }
        itemCode: "ITEMCODE"
        metadata: { field: { name: "Keywords" }, value: "API3" } } } ) {
    assets {
      id
    }
  }
}

Create a list of TXVersion assets with the given parameters.
In order to create an asset, user should have Insert rights on the category.

• Inputs - CreateTxVersionAssetsInput:

• Outputs - CreateAssetsOutput:

mutation createVideoAssets

Example: Create a video asset in category with id 0, with id 1 ("New") and the specified metadata

mutation {
  createVideoAssets(
    input: {
      assets: {
        assetName: "VideoAsset"
        categoryId: 0
        status: { id: 1 }
        itemCode: "ITEMCODE"
        metadata: {
          field: { name: "Title Keep Date" }, value: "2022-01-01T10:10:10.100" } } } ) {
    assets {
      id
    }
  }
}

Create a list of video assets with the given parameters.
In order to create an asset, user should have Insert rights on the category.

• Inputs - CreateVideoAssetsInput:

• Outputs - CreateAssetsOutput:

mutation deleteAssets

Example: Delete all video assets and their associated files from category with id 67

mutation {
  deleteAssets(
    input: {
      assetsWith: {
        categoriesWith: { ids: [67] }
        assetTypesWith: { mediaTypes: [VIDEO] }
      }
      purgeMedia: true
    } ) {
    deletedAssetIds
  }
}

Delete all assets matching the supplied filter.
In order to delete an asset, user should have Remove rights on the category of the asset.

• Inputs - DeleteAssetsInput:

• Outputs - DeleteAssetsOutput:

mutation linkAssetsToCategories

Example: Link asset with id 17392 to category with id 67

mutation {
  linkAssetsToCategories(
    input: { assetsWith: { ids: [17392] }, 
    linkedCategoriesWith: { ids: [67] } }
  ) {
    assets {
      id
      name
    }
  }
}

Link a list of assets to a list of categories.
In order to link an asset to a category, user should have Insert rights on the category and View rights on the category of the asset.

• Inputs - LinkAssetsToCategoriesInput:

• Outputs - LinkAssetsToCategoriesOutput:

mutation linkAssetToRunningOrderCategory

Example: Link asset with id 2004 to running order category with id 23

mutation {
  linkAssetToRunningOrderCategory(input: { assetId: 2004, categoryId: 23 }) {
    asset {
      id
      name
    }
  }
}

Link an asset to a running order category.
The mutation will not return empty even if the asset is already linked to the category in the same sequence.
In order to link an asset to a running order category, user should have Insert rights on the category and View rights on the category of the asset.

• Inputs - LinkAssetToRunningOrderCategoryInput:

• Outputs - LinkAssetToRunningOrderCategoryOutput:

mutation removeCGToVideoAssociations

Example: Remove association with id 180

mutation {
  removeCGToVideoAssociations(input: { associationIds: [180] }) {
    deletedAssociationIds
  }
}

Remove associations between CG assets and video assets.

• Inputs - RemoveCGToVideoAssociationsInput:

• Outputs - RemoveCGToVideoAssociationsOutput:

mutation removeItemsFromGroups

Example: Remove items with ids 1:1:1 and 1:1:2 from group with id 354890

mutation {
  removeItemsFromGroups(
    input: { groupItemsWith: { 
      groupAndIds: { groupId: 354890, groupItemIds: ["1:1:1", "1:1:2"] }
    } } ) {
    removedItemIdsByGroupId {
      groupId
      groupItemIds
    }
  }
}

Remove items from group assets matching the supplied filter.
In order to remove items from group assets, user should have Insert and Remove rights on the category of the group asset.

• Inputs - RemoveItemsFromGroupsInput:

• Outputs - RemoveItemsFromGroupsOutput:

mutation removeLinksFromCategories

Example: Remove links to category "To review" from all video assets with status "Approved" (status id = 4) in two "Incoming" categories

mutation {
    removeLinksFromCategories(input: {
        assetsWith: {
            assetTypesWith: { names: [ "Video" ] },
            metadata: { field: { tagName: "TitleStatus" }, value: [ "4" ] },
            categoriesWith: {fullNames: [ "CATEGORIES/Incoming/VendorA", "CATEGORIES/Incoming/VendorB" ]} },
        linkedCategoriesWith: { fullNames: [ "CATEGORIES/To review" ] } } ) {
        assets {
            id
        }
    }
}

Remove links between assets and categories matching the supplied filter.
All links to secondary categories can be deleted from an asset if no category is selected.

• Inputs - RemoveLinksFromCategoriesInput:

• Outputs - RemoveLinksFromCategoriesOutput:

mutation removeSubtitlesToVideoAssociations

Example: Remove association with id 205

mutation {
  removeSubtitlesToVideoAssociations(input: { associationIds: [205] }) {
    deletedAssociationIds
  }
}

Remove associations between subtitles assets and video assets.

• Inputs - RemoveSubtitlesToVideoAssociationsInput:

• Outputs - RemoveSubtitlesToVideoAssociationsOutput:

mutation updateAssets

Example: Update asset with id 17392 to be with status "Archive"

mutation {
  updateAssets(
    input: {
      assets: { id: 17392, assetStatus: { status: { name: "Archive" } } }
    } ) {
    assets {
      id
      name
      status {
        name
      }
    }
  }
}

Update a list of assets' fields with the given parameters.
In order to update an asset, user should have Insert and Remove rights on the category of the asset.

• Inputs - UpdateAssetsInput:

• Outputs - UpdateAssetsOutput:

subscription assets

Example: Subscribe to all types of notifications for video assets

subscription {
  assets(
    input: {
      notificationTypes: [ALL]
      assetsWith: { assetTypesWith: { mediaTypes: [VIDEO] } }
    }
  ) {
    notifications {
      contents {
        receivedAt
        rawNotification
        type
      }
    }
  }
}

Subscribe to notifications about assets.
In order to get the notifications for an asset, user should have View rights to its primary category.
Notifications of type DELETED will be emmited regardless of user rights.

• Inputs - AssetsSubscriptionInput:

• Outputs - AssetsSubscriptionOutput:

Categories

Describes operations to create, retrieve, update and delete categories.

query categories

Example: Retrieve information about all the categories under parent category with id 0 which are defined as running order

query {
    categories( input: { where: { 
        parentIds: ["0"]
        runningOrder: true 
    } } ) {
    totalCount
        categories {
            id
            name
        }
    } 
}

Retrieve information about categories matching the supplied filter.
Categories can be filtered by their ids, fullNames, codes, parentIds, system and runningOrder.
The retrieved categories are an intersection of all filter fields.
In order to retrieve a category, user should have View rights on the category.

• Inputs - CategoriesInput:

* Outputs - CategoriesOutput:

subqueries

Queries to retrieve information about categories from outputs of other operations.

• Category
  children: sub query to retrieve sub categories inside a Category

• AssetIfc
  categories: sub query to retrieve categories that the current asset is linked to

Example: Retrieve information about the categories that contain audio assets

query {
  assets(input: { where: { assetTypesWith: { mediaTypes: [AUDIO] } } }) {
    assets {
      categories {
        categories {
          id
          name
} } } } }

subquery categories

Retrieve categories that the current asset is linked to.
In order to retrieve a category, user should have View rights on the category.
See here categories

subquery children

Retrieve information about sub categories matching the supplied filter.
In order to retrieve a category, user should have View rights to the category and View rights to the parent category.

Example: Retrieve information about children sub-query in category

query {
    categories  {
        categories {
            children( input: { where: {
                ids: ["131",52] , 
                codes: ["GLOSSARIES"] , 
                system: true 
            } } ) {
                totalCount
                categories{
                    id
                    name
                }
            }
        }
    }
}

• Inputs - SubCategoryInput:

• Outputs - CategoriesOutput:

mutation createCategory

Example: Create a new category with the name "newSubCategory" and code "SUB01" inside category with id 1

mutation {
    createCategory ( input: {  
        name: "newSubCategory" ,
        parentCategoryId: 1 ,
        code: "SUB01"
    } ) {
    category {
      id
    }
  }
}

Create a new category with the given parameters.
In order to create a category, user should have Insert rights on the parent category.

• Inputs - CreateCategoryInput:

• Outputs - CreateCategoryOutput:

mutation createShotList

Example: Create a new shot list for user with id 12 with the name "My_ShotList"

mutation {
  createShotList ( input: {
    userId: 12 ,
    name: "My_ShotList"
    } ) {
    category {
      id
      fullName
    }
  }
}

Create a new shot list with the given parameters.
A shot list is a category with code UPCLB, runningOrder set to true and parent set to clipBin folder of the current user.
In order to create a shot list, user should have View rights on the clipBin category and Insert rights on the user's clipBin category.

• Inputs - CreateShotListInput:

• Outputs - CreateShotListOutput:

mutation deleteCategories

Example: Delete the categories 4445 and 4446 from the site

mutation {
  deleteCategories(input: { categoriesWith: { ids: [4445, 4446] } } ) {
    deletedCategoryIds
  }
}

Delete a list of categories.
In order to delete a category, user should have Insert and Remove rights to the category.

• Inputs - DeleteCategoriesInput!:

• Outputs - DeleteCategoriesOutput:

mutation linkAssetsToCategories

Please see linkAssetsToCategories

mutation linkAssetToRunningOrderCategory

Please see linkAssetToRunningOrderCategory

mutation removeLinksFromCategories

Please see removeLinksFromCategories

mutation updateCategory

Example: Change the name of category with id 2975 to "New name"

mutation {
  updateCategory ( input : {
    categoryId: 2795,
    name: "New name"
  } ) {
    category{
      id
    }
  }
}

Update Category information with the given parameters. In order to update a category, user should have View rights on the category and full rights on the parent category.

• Inputs - UpdateCategoryInput:

• Outputs - UpdateCategoryOutput:

subscription categories

Example: Subscribe to all types of notifications for categories

subscription {
  categories( input: {
        notificationTypes: [ALL] 
    } ) {
    notifications {
      category {
        id
      }
    }
  }
}

Subscribe to notifications about categories.

• Inputs - CategoriesSubscriptionInput:

• Outputs - CategoriesSubscriptionOutput:

Configuration

Describes operations to retrieve Galaxy five site parameters needed by other modules.

query assetStatuses

Example: Retrieve information about the following asset statuses: "New", "Approved" and "Archive"

query {
  assetStatuses(input: { where: { names: ["New", "Approved", "Archive"] } }) {
    totalCount
    assetStatuses {
      id
      name
      abbreviation
      description
      color
    }
  }
}

Retrieve information about asset statuses matching the supplied filter.
Asset statuses can be filtered by their ids, names, and abbreviations.
The retrieved asset statuses are an intersection of all filter fields.

• Inputs - AssetStatusesInput:

• Outputs - AssetStatusesOutput:

query blockTemplates

Example: Retrieve information about block templates with ids 1074 and 1075

query {
  blockTemplates(input: { where: { ids: [1074, 1075] } }) {
    totalCount
    blockTemplates {
      id
      name
      mediaType
      assetCanBeCreated
    }
  }
}

Retrieve information about block templates matching the supplied filter.
Block templates can be filtered by their ids and names.
The retrieved block templates are an intersection of all filter fields.

• Inputs - BlockTemplatesInput:

• Outputs - BlockTemplatesOutput:

query cgTypes

Example: Retrieve information about CG types with ids 1078 and 1080

query {
  cgTypes(input: { where: { ids: [1078, 1080] } }) {
    totalCount
    cgTypes {
      id
      name
      assetCanBeCreated
      withFile
    }
  }
}

Retrieve information about CG types matching the supplied filter.
CG types can be filtered by their ids and names.
The retrieved CG types are an intersection of all filter fields.

• Inputs - CgTypesInput:

• Outputs - CgTypesOutput:

query dataFields

Example: Retrieve information about data fields with names: "Task Assignee", "Task Created Time"

query {
  dataFields(
    input: { where: { names: ["Task Assignee", "Task Created Time"] } }
    ) {
        totalCount
        dataFields {
          id
          name
          inherited
          readOnly
    }
  }
}

Retrieve information about data fields matching the supplied filter.
Data fields can be filtered by their ids, tag names and names.
The retrieved data fields are an intersection of all filter fields.

• Inputs - DataFieldsInput:

• Outputs - DataFieldsOutput:

query dataFieldTableTypes

Example: Retrieve information about all the data fields of type table on site and display the first 12 in the first page

query {
  dataFieldTableTypes(input: { select: { first: 12 } }) {
    totalCount
    dataFieldTableTypes {
      name
    }
  }
}

Retrieve information about data fields of type table matching the supplied filter.
Data field table types can be filtered by their names.

• Inputs - DataFieldTableTypesInput:

• Outputs - DataFieldTableTypesOutput:

query dataFieldTypes

Example: Retrieve information about all data field types configured on site and display the first 50 data field types in the first page

query {
  dataFieldTypes(input: { select: { first: 50 } }) {
    totalCount
    dataFieldTypes {
      name
    }
  }
}

Retrieve information about data field types matching the supplied filter.
Data field types can be filtered by their names.

• Inputs - DataFieldTypesInput:

• Outputs - DataFieldTypesOutput:

query deployedSolrIndexes

Example: Retrieve information about the deployed SolR index "API3_Index"

query {
  deployedSolrIndexes(input: { where: { names: "API3_Index" } }) {
    totalCount
    solrIndexes {
      id
      name
      solrVersion
      version
      url
      cores {
        language {
          name }
        mapping {
          solrField {
            name }
          usage
        }
      }
    }
  }
}