Tłumacz strony dla wielojęzycznej witryny WordPress (Classic editor)

To GraphQL query pomaga tworzyć wielojęzyczną witrynę, w której każda witryna jest tłumaczeniem na określony język. Treść oparta jest na Classic editor i jest najbardziej odpowiednia do sieci multisite WordPress.
To query wymaga, aby endpoint miał włączone Zagnieżdżone Mutacje.
Query musi być wykonywane na witrynie master (z treścią źródłową), która musi mieć zainstalowany pakiet "Power Extensions". Wszystkie inne witryny w sieci mogą korzystać z darmowego pluginu Gato GraphQL.
Application Password służy do łączenia się z witrynami sieci. Upewnij się, że podajesz zmienne $username i $appPassword dla użytkownika mającego dostęp do wszystkich witryn.
Query pobiera język z witryny głównej i z witryny zewnętrznej, a następnie je porównuje:
Jeśli są takie same, po prostu replikuje wszystkie strony
Jeśli są różne, replikuje wszystkie strony z przetłumaczoną treścią
(W ten sposób, jeśli witryna główna ma język en, a inna witryna w sieci również ma en, wszystkie strony i tak są replikowane.)
Następnie pobiera strony z witryny master i (jeśli wymagane) tłumaczy je wszystkie naraz na język witryny docelowej, wykonując pojedyncze wywołanie API Google Translate.
Na koniec tworzy wszystkie te strony w witrynie zewnętrznej.
########################################################################
# 
# Variables:
#   - $username: The username to log into the external site
#   - $appPassword: The application password to log into the external site
#   - $externalSiteURL: The URL of the external site, where all pages will be (translated and) created
#   - (Optional) $pageIDs: Restrict translating/creating the pages with given IDs
#   - (Optional) $pageStatus: Fetch pages with given status
#   - (Optional) $externalSiteGraphQLEndpointPath: Path to the GraphQL endpoint on the external site
#
# *********************************************************************
#
# === Description ===
#
# This Persisted GraphQL query helps create a Multilingual site
# where every site is the translation for some language. The content
# is based on the Classic editor, and it is most suitable with a
# WordPress multisite network.
# 
# It must be executed on the master site, which must have the PRO plugin.
# All other sites in the network can have the free Gato GraphQL plugin.
#
# The query retrieves the language from the main site and from the external
# site, and compares them:
#
#   - If they are the same, simply replicate all pages
#   - If they are different, replicate all pages with translated content
#
#   (This way, if the main site has "en" language, and another site in
#   the network also has "en", all pages are still replicated.)
#
# Then it grabs all the pages from the master site, and (if required) it
# translates them all at once (in bulk) to the destination site's language,
# by executing a single call to the Google Translate API.
#
# Finally it creates all those pages in the external site.
#
########################################################################
 
query InitializeExternalSiteVariables
  @configureWarningsOnExportingDuplicateVariable(enabled: false)
{
  isGutenbergEditorEnabled
    @export(as: "isGutenbergEditorEnabled")
 
  emptyBool: _echo(value: false)
    @export(as: "hasMasterPages")
    @export(as: "executeTranslation")
    @remove
}
 
query ExportData(
  $username: String!
  $appPassword: String!
  $externalSiteURL: URL!
  $externalSiteGraphQLEndpointPath: String! = "/graphql/internal/"
  $pageIDs: [ID!]! = []
  $pageStatus: [CustomPostStatusEnum!]! = [publish]
)
  @depends(on: "InitializeExternalSiteVariables")
  @skip(if: $isGutenbergEditorEnabled)
{
  # Retrieve the language of the content
  siteLanguage
    @export(as: "fromLanguage")
 
  # Generate the authorization header to connect to the external site
  loginCredentials: _sprintf(
    string: "%s:%s",
    values: [$username, $appPassword]
  )
    @remove
  base64EncodedLoginCredentials: _strBase64Encode(
    string: $__loginCredentials
  )
    @remove
  authorizationHeaderValue: _sprintf(
    string: "Basic %s",
    values: [$__base64EncodedLoginCredentials]
  )
    @remove
    @export(as: "authorizationHeaderValue")
  
  # Generate the external site's GraphQL endpoint to connect to
  endpoint: _sprintf(
    string: "%s%s",
    values: [
      $externalSiteURL,
      $externalSiteGraphQLEndpointPath
    ]
  )
    @export(as: "endpoint")
    
  masterPages: pages(filter: { ids: $pageIDs, status: $pageStatus }) {
    id
    emptyArray: _echo(value: [])
      @export(
        as: "rawTitle"
        type: DICTIONARY
      )
      @export(
        as: "rawContent"
        type: DICTIONARY
      )
      @export(
        as: "rawExcerpt"
        type: DICTIONARY
      )
      @remove
  }
 
  hasMasterPages: _notEmpty(value: $__masterPages)
    @export(as: "hasMasterPages")
}
 
query RetrieveAndExportExternalSiteLanguage
  @depends(on: "ExportData")
  @include(if: $hasMasterPages)
{
  # Retrieve the language of the external site
  externalHTTPRequest: _sendGraphQLHTTPRequest(input:{
    endpoint: $endpoint,
    query: """
  
{
  me {
    name
  }
  siteLanguage
}
 
    """,
    options: {
      headers: [
        {
          name: "Authorization",
          value: $authorizationHeaderValue
        }
      ]
    }
  })
  externalSiteLanguage: _objectProperty(
    object: $__externalHTTPRequest,
    by: {
      path: "data.siteLanguage"
    }
  )
    @export(as: "toLanguage")
  
  # Indicate if connecting to the external site was successful
  hasRetrievedExternalSiteLanguage: _notEmpty(
    value: $__externalSiteLanguage
  )
 
  # Only translate the content if the master/destination sites languages are different
  areFromToLanguagesDifferent: _notEquals(
    value1: $fromLanguage
    value2: $__externalSiteLanguage
  )
 
  # Flag to indicate if to translate the content
  executeTranslation: _and(
    values: [
      $__hasRetrievedExternalSiteLanguage,
      $__areFromToLanguagesDifferent,
    ]
  )
    @export(as: "executeTranslation")
}
 
query FetchData(
  $pageIDs: [ID!]! = []
  $pageStatus: [CustomPostStatusEnum!]! = [publish]
)
  @depends(on: "RetrieveAndExportExternalSiteLanguage")
  @include(if: $hasMasterPages)
{
  fetchDataPages: pages(filter: { ids: $pageIDs, status: $pageStatus }) {
    id
 
 
    rawTitle
      @export(
        as: "rawTitle"
        type: DICTIONARY
      )
    rawContent
      @export(
        as: "rawContent"
        type: DICTIONARY
      )
    rawExcerpt
      @export(
        as: "rawExcerpt"
        type: DICTIONARY
      )
  }
}
 
query AdaptData
  @depends(on: "FetchData")
  @include(if: $hasMasterPages)
{
  adaptedToRawTitle: _echo(value: $rawTitle)
    @underEachJSONObjectProperty(
      passValueOnwardsAs: "value"
    )
      @applyField(
        name: "_echo"
        arguments: {
          value: [$value]
        }
        setResultInResponse: true
      )
    @export(as: "adaptedToRawTitle")
  adaptedFromTitle: _echo(value: $rawTitle)
    @underEachJSONObjectProperty
      @applyField(
        name: "_echo"
        arguments: {
          value: [""]
        }
        setResultInResponse: true
      )
    @export(as: "adaptedFromTitle")
 
  adaptedToRawContent: _echo(value: $rawContent)
    @underEachJSONObjectProperty(
      passValueOnwardsAs: "value"
    )
      @applyField(
        name: "_echo"
        arguments: {
          value: [$value]
        }
        setResultInResponse: true
      )
    @export(as: "adaptedToRawContent")
  adaptedFromRawContent: _echo(value: $rawContent)
    @underEachJSONObjectProperty
      @applyField(
        name: "_echo"
        arguments: {
          value: [""]
        }
        setResultInResponse: true
      )
    @export(as: "adaptedFromRawContent")
 
  adaptedToRawExcerpt: _echo(value: $rawExcerpt)
    @underEachJSONObjectProperty(
      passValueOnwardsAs: "value"
    )
      @applyField(
        name: "_echo"
        arguments: {
          value: [$value]
        }
        setResultInResponse: true
      )
    @export(as: "adaptedToRawExcerpt")
  adaptedFromRawExcerpt: _echo(value: $rawExcerpt)
    @underEachJSONObjectProperty
      @applyField(
        name: "_echo"
        arguments: {
          value: [""]
        }
        setResultInResponse: true
      )
    @export(as: "adaptedFromRawExcerpt")
}
 
query TransformData
  @depends(on: "AdaptData")
  @include(if: $hasMasterPages)
{
  transformations: _echo(value: {
    metaRawTitle: {
      from: $adaptedFromTitle,
      to: $adaptedToRawTitle,
    },
    metaRawContent: {
      from: $adaptedFromRawContent,
      to: $adaptedToRawContent,
    },
    metaRawExcerpt: {
      from: $adaptedFromRawExcerpt,
      to: $adaptedToRawExcerpt,
    }
  })
    @if(condition: $executeTranslation)
      @underEachJSONObjectProperty
        @underJSONObjectProperty(by: { key: "to" })
          @underEachJSONObjectProperty
            @underEachArrayItem
              @strTranslate(
                from: $fromLanguage,
                to: $toLanguage
              )
    @export(as: "transformations")
}
 
query PrepareMetaReplacements
  @depends(on: "TransformData")
  @include(if: $hasMasterPages)
{
  transformedMetaTitle: _echo(value: $rawTitle)
    @underEachJSONObjectProperty(
      passKeyOnwardsAs: "pageID"
      affectDirectivesUnderPos: [1, 2, 3]
    )
      @applyField(
        name: "_sprintf",
        arguments: {
          string: "metaRawTitle.to.%s",
          values: [$pageID]
        }
        passOnwardsAs: "titlePath"
      )
      @applyField(
        name: "_objectProperty",
        arguments: {
          object: $transformations
          by: { path: $titlePath }
        }
        passOnwardsAs: "transformedPostTitleAsArray"
      )
      @applyField(
        name: "_arrayItem",
        arguments: {
          array: $transformedPostTitleAsArray
          position: 0
        }
        setResultInResponse: true
      )
    @export(
      as: "transformedRawTitle"
    )
 
  transformedMetaRawContent: _echo(value: $rawContent)
    @underEachJSONObjectProperty(
      passKeyOnwardsAs: "pageID"
      affectDirectivesUnderPos: [1, 2, 3]
    )
      @applyField(
        name: "_sprintf",
        arguments: {
          string: "metaRawContent.to.%s",
          values: [$pageID]
        }
        passOnwardsAs: "rawContentPath"
      )
      @applyField(
        name: "_objectProperty",
        arguments: {
          object: $transformations
          by: { path: $rawContentPath }
        }
        passOnwardsAs: "transformedPostRawContentAsArray"
      )
      @applyField(
        name: "_arrayItem",
        arguments: {
          array: $transformedPostRawContentAsArray
          position: 0
        }
        setResultInResponse: true
      )
    @export(
      as: "transformedRawContent"
    )
 
  transformedMetaRawExcerpt: _echo(value: $rawExcerpt)
    @underEachJSONObjectProperty(
      passKeyOnwardsAs: "pageID"
      affectDirectivesUnderPos: [1, 2, 3]
    )
      @applyField(
        name: "_sprintf",
        arguments: {
          string: "metaRawExcerpt.to.%s",
          values: [$pageID]
        }
        passOnwardsAs: "rawExcerptPath"
      )
      @applyField(
        name: "_objectProperty",
        arguments: {
          object: $transformations
          by: { path: $rawExcerptPath }
        }
        passOnwardsAs: "transformedPostRawExcerptAsArray"
      )
      @applyField(
        name: "_arrayItem",
        arguments: {
          array: $transformedPostRawExcerptAsArray
          position: 0
        }
        setResultInResponse: true
      )
    @export(
      as: "transformedRawExcerpt"
    )
}
 
query ExportMutationInputs(
  $pageIDs: [ID!]! = []
  $pageStatus: [CustomPostStatusEnum!]! = [publish]
)
  @depends(on: "PrepareMetaReplacements")
  @include(if: $hasMasterPages)
{
  exportPages: pages(filter: { ids: $pageIDs, status: $pageStatus }) {
    id
    transformedRawContent: _objectProperty(
      object: $transformedRawContent,
      by: {
        key: $__id
      }
    )
    transformedRawTitle: _objectProperty(
      object: $transformedRawTitle,
      by: {
        key: $__id
      }
    )
    transformedSlug: _echo(value: $__transformedRawTitle)
    transformedRawExcerpt: _objectProperty(
      object: $transformedRawExcerpt,
      by: {
        key: $__id
      }
    )
    input: _echo(value: {
      status: draft,
      title: $__transformedRawTitle,
      slug: $__transformedSlug,
      excerpt: $__transformedRawExcerpt,
      contentAs: {
        html: $__transformedRawContent
      }
    })
      @export(
        as: "createPostMutationInputs"
        type: LIST
      )
  }
}
 
mutation CreatePagesWithTranslationOnExternalSite
  @depends(on: "ExportMutationInputs")
  @include(if: $hasMasterPages)
{
  createExternalSitePageHTTPRequests: _echo(value: $createPostMutationInputs)
    @underEachArrayItem(
      passValueOnwardsAs: "input"
    )
      @applyField(
        name: "_sendGraphQLHTTPRequest"
        arguments: {
          input: {
            endpoint: $endpoint,
            query: """
          
mutation CreatePageFromMasterSite($input: JSONObject!) {
  createPage(input: $input) {
    status
    errors {
      __typename
      ...on ErrorPayload {
        message
      }
    }
    page {
      id
      slug
      title
      content
      status
      url
      excerpt
    }
  }
}
 
            """,
            variables: [
              {
                name: "input",
                value: $input
              }
            ],
            options: {
              headers: [
                {
                  name: "Authorization",
                  value: $authorizationHeaderValue
                }
              ]
            }
          }
        },
        setResultInResponse: true
      )
}