WooCommerce

Esempi di queries per recuperare dati dal plugin WooCommerce.

Prodotti (Tutti)

Questa query recupera tutti i prodotti con le loro informazioni di base:

query FetchAllProducts {
  woocommerceProducts {
    __typename
    id
    name
    slug
    url
    urlPath
    sku
    ...on WooCommercePriceableProductOrProductVariation {
      price
      priceFormatted
      regularPrice
      regularPriceFormatted
      salePrice
      salePriceFormatted
      onSale
    }
    status
    type
    featured
    totalSales
    averageRating
    ratingCount
    image {
      id
      src
      altText
      title
      caption
    }
    categories {
      id
      name
      slug
    }
    tags {
      id
      name
      slug
    }
    brands {
      id
      name
      slug
    }
  }
  woocommerceProductsCount
}

Questa query recupera un singolo prodotto tramite ID:

query FetchProduct($productId: ID!) {
  woocommerceProduct(by: { id: $productId }) {
    __typename
    id
    name
    slug
    url
    urlPath
    sku
    description
    shortDescription
    ...on WooCommercePriceableProductOrProductVariation {
      price
      priceFormatted
      regularPrice
      regularPriceFormatted
      salePrice
      salePriceFormatted
      onSale
    }
    status
    type
    featured
    totalSales
    averageRating
    ratingCount
    image {
      id
      src
      altText
      title
      caption
    }
    galleryImages {
      id
      src
      altText
      title
      caption
    }
    categories {
      id
      name
      slug
    }
    tags {
      id
      name
      slug
    }
    brands {
      id
      name
      slug
    }
    attributes {
      name
      options
      position
      isVisible
      isVariation
    }
  }
}

Questa query recupera un prodotto tramite slug:

query FetchProductBySlug($slug: String!) {
  productBySlug: woocommerceProduct(by: { slug: $slug }) {
    __typename
    id
    name
    slug
    url
    sku
  }
}

Questa query recupera un prodotto tramite SKU:

query FetchProductBySku($sku: String!) {
  productBySku: woocommerceProduct(by: { sku: $sku }) {
    __typename
    id
    name
    slug
    url
    sku
  }
}

Categorie, etichette e marchi di prodotti

Questa query recupera tutte le categorie di prodotti:

query FetchProductCategories {
  woocommerceProductCategories {
    __typename
    id
    url
    urlPath
    slug
    name
    description
    count
    slugPath
    parentID
    parent {
      id
      name
      slug
    }
    thumbnail {
      id
      src
      altText
      title
      caption
    }
    displayType
    menuOrder
    ancestors {
      id
      name
      slug
    }
    children {
      id
      name
      slug
      parent {
        id
        name
        slug
      }
    }
    childrenCount
    descendants {
      id
      name
      slug
      ancestors {
        id
        name
        slug
      }
    }
    descendantsCount
  }
  woocommerceProductCategoriesCount
}

Questa query recupera una singola categoria di prodotto tramite ID:

query FetchProductCategory($categoryId: ID!) {
  woocommerceProductCategory(by: { id: $categoryId }) {
    __typename
    id
    url
    urlPath
    slug
    name
    description
    count
    slugPath
    parentID
    parent {
      id
      name
      slug
    }
    thumbnail {
      id
      src
      altText
      title
      caption
    }
    displayType
    menuOrder
    ancestors {
      id
      name
      slug
    }
    children {
      id
      name
      slug
      parent {
        id
        name
        slug
      }
    }
    childrenCount
    descendants {
      id
      name
      slug
      ancestors {
        id
        name
        slug
      }
    }
    descendantsCount
  }
}

Questa query recupera tutte le etichette di prodotti:

query FetchProductTags {
  woocommerceProductTags {
    __typename
    id
    name
    slug
    url
    urlPath
    description
    count
    thumbnail {
      id
      src
      altText
      title
      caption
    }
    menuOrder
  }
  woocommerceProductTagsCount
}

Questa query recupera una singola etichetta di prodotto tramite ID:

query FetchProductTag($tagId: ID!) {
  woocommerceProductTag(by: { id: $tagId }) {
    __typename
    id
    name
    slug
    url
    urlPath
    description
    count
    thumbnail {
      id
      src
      altText
      title
      caption
    }
    menuOrder
  }
}

Questa query recupera tutti i marchi di prodotti:

query FetchProductBrands {
  woocommerceProductBrands {
    __typename
    id
    url
    urlPath
    slug
    slugPath
    name
    description
    count
    parentID
    parent {
      id
      name
      slug
    }
    thumbnail {
      id
      src
      altText
      title
      caption
    }
    menuOrder
    ancestors {
      id
      name
      slug
    }
    children {
      id
      name
      slug
      parent {
        id
        name
        slug
      }
    }
    childrenCount
    descendants {
      id
      name
      slug
      ancestors {
        id
        name
        slug
      }
    }
    descendantsCount
  }
  woocommerceProductBrandsCount
}

Questa query recupera un singolo marchio di prodotto tramite ID:

query FetchProductBrand($brandId: ID!) {
  woocommerceProductBrand(by: { id: $brandId }) {
    __typename
    id
    url
    urlPath
    slug
    slugPath
    name
    description
    count
    parentID
    parent {
      id
      name
      slug
    }
    thumbnail {
      id
      src
      altText
      title
      caption
    }
    menuOrder
    ancestors {
      id
      name
      slug
    }
    children {
      id
      name
      slug
      parent {
        id
        name
        slug
      }
    }
    childrenCount
    descendants {
      id
      name
      slug
      ancestors {
        id
        name
        slug
      }
    }
    descendantsCount
  }
}

Attributi e tassonomie di attributi

Questa query recupera tutte le tassonomie di attributi:

query FetchAttributeTaxonomies {
  woocommerceAttributeTaxonomies {
    __typename
    id
    name
    slug
    type
    orderBy
    taxonomy
    hasArchives
    public
  }
}

Questa query recupera una singola tassonomia di attributi tramite ID:

query FetchAttributeTaxonomy($taxonomyId: ID!) {
  woocommerceAttributeTaxonomy(by: { id: $taxonomyId }) {
    __typename
    id
    name
    slug
    type
    orderBy
    taxonomy
    hasArchives
    public
  }
}

Questa query recupera una tassonomia di attributi tramite nome:

query FetchAttributeTaxonomyByName($taxonomyName: String!) {
  attributeTaxonomyByName: woocommerceAttributeTaxonomy(by: { taxonomyName: $taxonomyName }) {
    __typename
    id
    name
    slug
    type
    orderBy
    taxonomy
    hasArchives
    public
  }
}

Questa query recupera tutti gli attributi di prodotti:

query FetchProductAttributes {
  woocommerceAttributes {
    __typename
    id
    url
    urlPath
    slug
    name
    description
    count
    menuOrder
    termGroup
    termTaxonomyID
    taxonomy
    taxonomyObject {
      id
      name
      slug
      type
      orderBy
      taxonomy
      hasArchives
      public
    }
  }
  woocommerceAttributesCount
}

Questa query recupera un singolo attributo di prodotto tramite ID:

query FetchProductAttribute($attributeId: ID!) {
  woocommerceAttribute(by: { id: $attributeId }) {
    __typename
    id
    url
    urlPath
    slug
    name
    description
    count
    menuOrder
    termGroup
    termTaxonomyID
    taxonomy
    taxonomyObject {
      id
      name
      slug
      type
      orderBy
      taxonomy
      hasArchives
      public
    }
  }
}

Questa query recupera un attributo di prodotto tramite slug e tassonomia:

query FetchProductAttributeBySlug($slug: String!, $taxonomy: String!) {
  attributeBySlug: woocommerceAttribute(by: { slug: $slug }, taxonomy: $taxonomy) {
    __typename
    id
    url
    urlPath
    slug
    name
    description
    count
    menuOrder
    termGroup
    termTaxonomyID
    taxonomy
    taxonomyObject {
      id
      name
      slug
      type
      orderBy
      taxonomy
      hasArchives
      public
    }
  }
}

Prodotti per tipo

Prodotti semplici

Questa query recupera tutti i prodotti semplici:

query FetchSimpleProducts {
  woocommerceSimpleProducts {
    __typename
    id
    name
    slug
    url
    urlPath
    sku
    description
    shortDescription
    price
    priceFormatted
    regularPrice
    regularPriceFormatted
    salePrice
    salePriceFormatted
    onSale
    status
    type
    featured
    totalSales
    averageRating
    ratingCount
    image {
      id
      src
      altText
      title
      caption
    }
    categories {
      id
      name
      slug
    }
    tags {
      id
      name
      slug
    }
    brands {
      id
      name
      slug
    }
    # Stock management fields
    manageStock
    stockQuantity
    stockStatus
    backorders
    backordersAllowed
    backordered
    soldIndividually
    lowStockThreshold
    # Shipping fields
    isVirtual
    weight
    length
    width
    height
    dimensions
    shippingClassID
    shippingClass {
      id
      name
      slug
      description
      count
    }
    # Downloadable fields
    isDownloadable
    downloadLimit
    downloadExpiry
    downloads
    downloadsCount
    # Tax fields
    taxStatus
    taxClass
    # Cross-sell fields
    crossSellIDs
    crossSells {
      id
      name
      slug
      sku
    }
  }
  woocommerceSimpleProductsCount
}

Questa query recupera un singolo prodotto semplice tramite ID:

query FetchSimpleProduct($productId: ID!) {
  woocommerceSimpleProduct(by: { id: $productId }) {
    __typename
    id
    name
    slug
    url
    urlPath
    sku
    description
    shortDescription
    price
    priceFormatted
    regularPrice
    regularPriceFormatted
    salePrice
    salePriceFormatted
    onSale
    status
    type
    featured
    totalSales
    averageRating
    ratingCount
    image {
      id
      src
      altText
      title
      caption
    }
    galleryImages {
      id
      src
      altText
      title
      caption
    }
    categories {
      id
      name
      slug
    }
    tags {
      id
      name
      slug
    }
    brands {
      id
      name
      slug
    }
    # Stock management fields
    manageStock
    stockQuantity
    stockStatus
    backorders
    backordersAllowed
    backordered
    soldIndividually
    lowStockThreshold
    # Shipping fields
    isVirtual
    weight
    length
    width
    height
    dimensions
    shippingClassID
    shippingClass {
      id
      name
      slug
      description
      count
    }
    # Downloadable fields
    isDownloadable
    downloadLimit
    downloadExpiry
    downloads
    downloadsCount
    # Tax fields
    taxStatus
    taxClass
    # Cross-sell fields
    crossSellIDs
    crossSells {
      id
      name
      slug
      sku
    }
  }
}

Prodotti esterni

Questa query recupera tutti i prodotti esterni:

query FetchExternalProducts {
  woocommerceExternalProducts {
    __typename
    id
    name
    slug
    url
    urlPath
    sku
    description
    shortDescription
    price
    priceFormatted
    regularPrice
    regularPriceFormatted
    salePrice
    salePriceFormatted
    onSale
    status
    type
    featured
    totalSales
    averageRating
    ratingCount
    image {
      id
      src
      altText
      title
      caption
    }
    categories {
      id
      name
      slug
    }
    tags {
      id
      name
      slug
    }
    brands {
      id
      name
      slug
    }
    # External product specific fields
    externalURL
    buttonText
    # Tax fields
    taxStatus
    taxClass
  }
  woocommerceExternalProductsCount
}

Questa query recupera un singolo prodotto esterno tramite ID:

query FetchExternalProduct($productId: ID!) {
  woocommerceExternalProduct(by: { id: $productId }) {
    __typename
    id
    name
    slug
    url
    urlPath
    sku
    description
    shortDescription
    price
    priceFormatted
    regularPrice
    regularPriceFormatted
    salePrice
    salePriceFormatted
    onSale
    status
    type
    featured
    totalSales
    averageRating
    ratingCount
    image {
      id
      src
      altText
      title
      caption
    }
    galleryImages {
      id
      src
      altText
      title
      caption
    }
    categories {
      id
      name
      slug
    }
    tags {
      id
      name
      slug
    }
    brands {
      id
      name
      slug
    }
    # External product specific fields
    externalURL
    buttonText
    # Tax fields
    taxStatus
    taxClass
  }
}

Prodotti raggruppati

Questa query recupera tutti i prodotti raggruppati:

query FetchGroupProducts {
  woocommerceGroupProducts {
    __typename
    id
    name
    slug
    url
    urlPath
    sku
    description
    shortDescription
    status
    type
    featured
    totalSales
    averageRating
    ratingCount
    image {
      id
      src
      altText
      title
      caption
    }
    categories {
      id
      name
      slug
    }
    tags {
      id
      name
      slug
    }
    brands {
      id
      name
      slug
    }
    # Group product specific fields
    hasChildren
    childrenCount
    minPrice
    maxPrice
    minPriceFormatted
    maxPriceFormatted
    children {
      id
      name
      slug
      sku
    }
  }
  woocommerceGroupProductsCount
}

Questa query recupera un singolo prodotto raggruppato tramite ID:

query FetchGroupProduct($productId: ID!) {
  woocommerceGroupProduct(by: { id: $productId }) {
    __typename
    id
    name
    slug
    url
    urlPath
    sku
    description
    shortDescription
    status
    type
    featured
    totalSales
    averageRating
    ratingCount
    image {
      id
      src
      altText
      title
      caption
    }
    galleryImages {
      id
      src
      altText
      title
      caption
    }
    categories {
      id
      name
      slug
    }
    tags {
      id
      name
      slug
    }
    brands {
      id
      name
      slug
    }
    # Group product specific fields
    hasChildren
    childrenCount
    minPrice
    maxPrice
    minPriceFormatted
    maxPriceFormatted
    children {
      id
      name
      slug
      sku
    }
  }
}

Prodotti variabili

Questa query recupera tutti i prodotti variabili:

query FetchVariableProducts {
  woocommerceVariableProducts {
    __typename
    id
    name
    slug
    url
    urlPath
    sku
    description
    shortDescription
    status
    type
    featured
    totalSales
    averageRating
    ratingCount
    image {
      id
      src
      altText
      title
      caption
    }
    categories {
      id
      name
      slug
    }
    tags {
      id
      name
      slug
    }
    brands {
      id
      name
      slug
    }
    # Variable product specific fields
    hasVariations
    variationsCount
    minPrice
    maxPrice
    minRegularPrice
    maxRegularPrice
    minSalePrice
    maxSalePrice
    priceRange
    variations {
      id
      name
      slug
      sku
    }
    defaultAttributes {
      taxonomy
      termSlug
      termObject {
        id
        name
        slug
      }
    }
    # Cross-sell fields
    crossSellIDs
    crossSells {
      id
      name
      slug
      sku
    }
    # Tax fields
    taxStatus
    taxClass
  }
  woocommerceVariableProductsCount
}

Questa query recupera un singolo prodotto variabile tramite ID:

query FetchVariableProduct($productId: ID!) {
  woocommerceVariableProduct(by: { id: $productId }) {
    __typename
    id
    name
    slug
    url
    urlPath
    sku
    description
    shortDescription
    status
    type
    featured
    totalSales
    averageRating
    ratingCount
    image {
      id
      src
      altText
      title
      caption
    }
    galleryImages {
      id
      src
      altText
      title
      caption
    }
    categories {
      id
      name
      slug
    }
    tags {
      id
      name
      slug
    }
    brands {
      id
      name
      slug
    }
    # Variable product specific fields
    hasVariations
    variationsCount
    minPrice
    maxPrice
    minRegularPrice
    maxRegularPrice
    minSalePrice
    maxSalePrice
    priceRange
    variations {
      id
      name
      slug
      sku
    }
    defaultAttributes {
      taxonomy
      termSlug
      termObject {
        id
        name
        slug
      }
    }
    # Cross-sell fields
    crossSellIDs
    crossSells {
      id
      name
      slug
      sku
    }
    # Tax fields
    taxStatus
    taxClass
  }
}

Varianti di prodotto

Questa query recupera tutte le varianti di prodotto:

query FetchProductVariations {
  woocommerceProductVariations {
    __typename
    id
    name
    slug
    sku
    description
    shortDescription
    price
    priceFormatted
    regularPrice
    regularPriceFormatted
    salePrice
    salePriceFormatted
    onSale
    status
    image {
      id
      src
      altText
      title
      caption
    }
    # Product variation specific fields
    parentID
    parent {
      id
      name
      slug
      sku
    }
    taxClass
    attributes {
      taxonomy
      termSlug
      termObject {
        id
        name
        slug
      }
    }
    # Stock management fields
    manageStock
    stockQuantity
    stockStatus
    backorders
    backordersAllowed
    backordered
    soldIndividually
    lowStockThreshold
    # Shipping fields
    isVirtual
    weight
    length
    width
    height
    dimensions
    shippingClassID
    shippingClass {
      id
      name
      slug
      description
      count
    }
    # Downloadable fields
    isDownloadable
    downloadLimit
    downloadExpiry
    downloads
    downloadsCount
  }
  woocommerceProductVariationsCount
}

Questa query recupera una singola variante di prodotto tramite ID:

query FetchProductVariation($variationId: ID!) {
  woocommerceProductVariation(by: { id: $variationId }) {
    __typename
    id
    name
    slug
    sku
    description
    shortDescription
    price
    priceFormatted
    regularPrice
    regularPriceFormatted
    salePrice
    salePriceFormatted
    onSale
    status
    image {
      id
      src
      altText
      title
      caption
    }
    # Product variation specific fields
    parentID
    parent {
      id
      name
      slug
      sku
    }
    taxClass
    attributes {
      taxonomy
      termSlug
      termObject {
        id
        name
        slug
      }
    }
    # Stock management fields
    manageStock
    stockQuantity
    stockStatus
    backorders
    backordersAllowed
    backordered
    soldIndividually
    lowStockThreshold
    # Shipping fields
    isVirtual
    weight
    length
    width
    height
    dimensions
    shippingClassID
    shippingClass {
      id
      name
      slug
      description
      count
    }
    # Downloadable fields
    isDownloadable
    downloadLimit
    downloadExpiry
    downloads
    downloadsCount
  }
}

Clienti

Questa query recupera tutti i clienti:

query FetchCustomers {
  woocommerceCustomers {
    __typename
    id
    username
    email
    firstName
    lastName
    displayName
    description
    createdDate
    createdDateStr
    formattedCreatedDateStr: createdDateStr(format: "d/m/Y H:i:s")
    modifiedDate
    modifiedDateStr
    formattedModifiedDateStr: modifiedDateStr(format: "d/m/Y H:i:s")
    role
    billing
    shipping
    isPayingCustomer
    avatarURL
    totalSpent
    totalSpentFormatted
    orderCount
    lastOrderID
    lastOrder {
      id
      orderNumber
      status
      total
      date
    }
    orders {
      id
      orderNumber
      status
      total
      date
    }
    ordersCount
  }
  woocommerceCustomersCount
}

Questa query recupera un singolo cliente tramite ID:

query FetchCustomer($customerId: ID!) {
  woocommerceCustomer(by: { id: $customerId }) {
    __typename
    id
    username
    email
    firstName
    lastName
    displayName
    description
    createdDate
    createdDateStr
    formattedCreatedDateStr: createdDateStr(format: "d/m/Y H:i:s")
    modifiedDate
    modifiedDateStr
    formattedModifiedDateStr: modifiedDateStr(format: "d/m/Y H:i:s")
    role
    billing
    shipping
    isPayingCustomer
    avatarURL
    totalSpent
    totalSpentFormatted
    orderCount
    lastOrderID
    lastOrder {
      id
      orderNumber
      status
      total
      date
    }
    orders {
      id
      orderNumber
      status
      total
      date
    }
    ordersCount
  }
}

Ordini

Questa query recupera tutti gli ordini:

query FetchOrders {
  woocommerceOrders {
    __typename
    id
    orderNumber
    orderKey
    date
    modifiedDate
    dateStr
    formattedDateStr: dateStr(format: "d/m/Y H:i:s")
    modifiedDateStr
    formattedModifiedStr: modifiedDateStr(format: "d/m/Y H:i:s")
    status
    isPaid
    currency
    total
    totalFormatted
    subtotal
    subtotalFormatted
    totalTax
    totalTaxFormatted
    totalShipping
    totalShippingFormatted
    totalDiscount
    totalDiscountFormatted
    totalDiscountTax
    totalDiscountTaxFormatted
    shippingTotal
    shippingTotalFormatted
    shippingTax
    shippingTaxFormatted
    cartTax
    cartTaxFormatted
    totalFee
    totalFeeFormatted
    customerID
    customer {
      id
      username
      email
      firstName
      lastName
      displayName
    }
    customerNote
    billingAddress
    shippingAddress
    hasCompletedStatus: hasStatus(status: "completed")
    hasPendingStatus: hasStatus(status: "pending")
    hasProcessingStatus: hasStatus(status: "processing")
    hasOnHoldStatus: hasStatus(status: "on-hold")
    hasCancelledStatus: hasStatus(status: "cancelled")
    hasRefundedStatus: hasStatus(status: "refunded")
    hasFailedStatus: hasStatus(status: "failed")
    hasAnyCompletedOrProcessingStatus: hasAnyStatus(statuses: ["completed", "processing"])
    hasAnyPendingOrOnHoldStatus: hasAnyStatus(statuses: ["pending", "on-hold"])
    paymentMethod
    paymentMethodTitle
    transactionID
    datePaid
    datePaidStr
    formattedDatePaidStr: datePaidStr(format: "d/m/Y H:i:s")
    dateCompleted
    dateCompletedStr
    formattedDateCompletedStr: dateCompletedStr(format: "d/m/Y H:i:s")
    cartHash
    newOrderEmailSent
    orderCurrency
    orderVersion
    pricesIncludeTax
    discountTotal
    discountTax
    refunded
    remainingRefundAmount
    itemCount
    items {
      id
      name
      quantity
      subtotal
      subtotalFormatted
      total
      totalFormatted
      totalTax
      totalTaxFormatted
      productID
      variationID
      reducedStockNumber
      product {
        id
        name
        slug
        sku
      }
      variation {
        id
        name
        slug
        sku
      }
    }
    refunds {
      id
      amount
      amountFormatted
      reason
      status
    }
    downloadPermissionsGranted
    needsPayment
    needsProcessing
    isDownloadPermitted
    hasDownloadableItem
  }
  woocommerceOrdersCount
}

Questa query recupera un singolo ordine tramite ID:

query FetchOrder($orderId: ID!) {
  woocommerceOrder(by: { id: $orderId }) {
    __typename
    id
    orderNumber
    orderKey
    date
    modifiedDate
    dateStr
    formattedDateStr: dateStr(format: "d/m/Y H:i:s")
    modifiedDateStr
    formattedModifiedStr: modifiedDateStr(format: "d/m/Y H:i:s")
    status
    isPaid
    currency
    total
    totalFormatted
    subtotal
    subtotalFormatted
    totalTax
    totalTaxFormatted
    totalShipping
    totalShippingFormatted
    totalDiscount
    totalDiscountFormatted
    totalDiscountTax
    totalDiscountTaxFormatted
    shippingTotal
    shippingTotalFormatted
    shippingTax
    shippingTaxFormatted
    cartTax
    cartTaxFormatted
    totalFee
    totalFeeFormatted
    customerID
    customer {
      id
      username
      email
      firstName
      lastName
      displayName
    }
    customerNote
    billingAddress
    shippingAddress
    hasCompletedStatus: hasStatus(status: "completed")
    hasPendingStatus: hasStatus(status: "pending")
    hasProcessingStatus: hasStatus(status: "processing")
    hasOnHoldStatus: hasStatus(status: "on-hold")
    hasCancelledStatus: hasStatus(status: "cancelled")
    hasRefundedStatus: hasStatus(status: "refunded")
    hasFailedStatus: hasStatus(status: "failed")
    hasAnyCompletedOrProcessingStatus: hasAnyStatus(statuses: ["completed", "processing"])
    hasAnyPendingOrOnHoldStatus: hasAnyStatus(statuses: ["pending", "on-hold"])
    paymentMethod
    paymentMethodTitle
    transactionID
    datePaid
    datePaidStr
    formattedDatePaidStr: datePaidStr(format: "d/m/Y H:i:s")
    dateCompleted
    dateCompletedStr
    formattedDateCompletedStr: dateCompletedStr(format: "d/m/Y H:i:s")
    cartHash
    newOrderEmailSent
    orderCurrency
    orderVersion
    pricesIncludeTax
    discountTotal
    discountTax
    refunded
    remainingRefundAmount
    itemCount
    items {
      id
      name
      quantity
      subtotal
      subtotalFormatted
      total
      totalFormatted
      totalTax
      totalTaxFormatted
      productID
      variationID
      reducedStockNumber
      product {
        id
        name
        slug
        sku
      }
      variation {
        id
        name
        slug
        sku
      }
    }
    refunds {
      id
      amount
      amountFormatted
      reason
      status
    }
    downloadPermissionsGranted
    needsPayment
    needsProcessing
    isDownloadPermitted
    hasDownloadableItem
  }
}

Questa query recupera un ordine tramite chiave dell'ordine:

query FetchOrderByKey($orderKey: String!) {
  orderByKey: woocommerceOrder(by: { orderKey: $orderKey }) {
    id
    orderKey
    orderNumber
    total
    totalFormatted
    status
    date
    customer {
      id
      username
      email
      firstName
      lastName
    }
  }
}

Rimborsi

Questa query recupera tutti i rimborsi:

query FetchRefunds {
  woocommerceRefunds {
    __typename
    id
    orderID
    order {
      id
      orderNumber
      status
    }
    amount
    amountFormatted
    reason
    refundedBy {
      id
      name
      email
    }
    isPaymentRefundedViaAPI
    refundType
    date
    modifiedDate
    dateStr
    formattedDateStr: dateStr(format: "d/m/Y H:i:s")
    modifiedDateStr
    formattedModifiedDateStr: modifiedDateStr(format: "d/m/Y H:i:s")
    status
  }
  woocommerceRefundsCount
}

Questa query recupera un singolo rimborso tramite ID:

query FetchRefund($refundId: ID!) {
  woocommerceRefund(by: { id: $refundId }) {
    __typename
    id
    orderID
    order {
      id
      orderNumber
      status
    }
    amount
    amountFormatted
    reason
    refundedBy {
      id
      name
      email
    }
    isPaymentRefundedViaAPI
    refundType
    date
    modifiedDate
    dateStr
    formattedDateStr: dateStr(format: "d/m/Y H:i:s")
    modifiedDateStr
    formattedModifiedDateStr: modifiedDateStr(format: "d/m/Y H:i:s")
    status
  }
}

Recensioni

Questa query recupera tutte le recensioni dei prodotti:

query FetchProductReviews {
  woocommerceReviews {
    __typename
    id
    content
    author
    authorEmail
    rating
    verified
    approved
    date
    dateStr
    productID
    product {
      id
      name
    }
  }
  woocommerceReviewsCount
}

Questa query recupera una singola recensione di prodotto tramite ID:

query FetchProductReview($reviewId: ID!) {
  woocommerceReview(by: { id: $reviewId }) {
    __typename
    id
    content
    author
    authorEmail
    rating
    verified
    approved
    date
    dateStr
    productID
    product {
      id
      name
    }
  }
}

Coupon

Questa query recupera tutti i coupon:

query FetchCoupons {
  woocommerceCoupons {
    __typename
    id
    code
    amount
    amountFormatted
    dateExpires
    dateExpiresStr
    formattedDateExpiresStr: dateExpiresStr(format: "d/m/Y H:i:s")
    discountType
    description
    date
    modifiedDate
    dateStr
    formattedDateStr: dateStr(format: "d/m/Y H:i:s")
    modifiedDateStr
    formattedModifiedDateStr: modifiedDateStr(format: "d/m/Y H:i:s")
    usageCount
    individualUse
    productIDs
    products {
      id
      name
      slug
    }
    productsCount
    excludedProductIDs
    excludedProducts {
      id
      name
      slug
    }
    excludedProductsCount
    usageLimit
    usageLimitPerUser
    limitUsageToXItems
    freeShipping
    productCategoryIDs
    productCategories {
      id
      name
      slug
    }
    productCategoriesCount
    excludedProductCategoryIDs
    excludedProductCategories {
      id
      name
      slug
    }
    excludedProductCategoriesCount
    productBrandIDs
    productBrands {
      id
      name
      slug
    }
    productBrandsCount
    excludedProductBrandIDs
    excludedProductBrands {
      id
      name
      slug
    }
    excludedProductBrandsCount
    excludeSaleItems
    minimumAmount
    minimumAmountFormatted
    maximumAmount
    maximumAmountFormatted
    emailRestrictions
    usedByCustomerIDs
    usedByCustomers {
      id
      username
      email
      firstName
      lastName
      displayName
    }
    usedByCustomersCount
  }
  woocommerceCouponsCount
}

Questa query recupera un coupon tramite codice:

query FetchCouponByCode($code: String!) {
  couponByCode: woocommerceCoupon(by: { code: $code }) {
    __typename
    id
    code
    amount
    amountFormatted
    dateExpires
    dateExpiresStr
    formattedDateExpiresStr: dateExpiresStr(format: "d/m/Y H:i:s")
    discountType
    description
    date
    modifiedDate
    dateStr
    formattedDateStr: dateStr(format: "d/m/Y H:i:s")
    modifiedDateStr
    formattedModifiedDateStr: modifiedDateStr(format: "d/m/Y H:i:s")
    usageCount
    individualUse
    productIDs
    products {
      id
      name
      slug
    }
    productsCount
    excludedProductIDs
    excludedProducts {
      id
      name
      slug
    }
    excludedProductsCount
    usageLimit
    usageLimitPerUser
    limitUsageToXItems
    freeShipping
    productCategoryIDs
    productCategories {
      id
      name
      slug
    }
    productCategoriesCount
    excludedProductCategoryIDs
    excludedProductCategories {
      id
      name
      slug
    }
    excludedProductCategoriesCount
    productBrandIDs
    productBrands {
      id
      name
      slug
    }
    productBrandsCount
    excludedProductBrandIDs
    excludedProductBrands {
      id
      name
      slug
    }
    excludedProductBrandsCount
    excludeSaleItems
    minimumAmount
    minimumAmountFormatted
    maximumAmount
    maximumAmountFormatted
    emailRestrictions
    usedByCustomerIDs
    usedByCustomers {
      id
      username
      email
      firstName
      lastName
      displayName
    }
    usedByCustomersCount
  }
}

Questa query recupera un coupon tramite ID:

query FetchCouponById($couponId: ID!) {
  couponByID: woocommerceCoupon(by: { id: $couponId }) {
    id
    code
    amount
    amountFormatted
    discountType
    description
    usageCount
    individualUse
    usageLimit
    usageLimitPerUser
    freeShipping
    excludeSaleItems
    minimumAmount
    minimumAmountFormatted
    maximumAmount
    maximumAmountFormatted
  }
}

Classi di spedizione

Questa query recupera tutte le classi di spedizione:

query FetchShippingClasses {
  woocommerceShippingClasses {
    __typename
    id
    name
    slug
    description
    count
  }
  woocommerceShippingClassesCount
}

Questa query recupera una singola classe di spedizione tramite ID:

query FetchShippingClassById($shippingClassId: ID!) {
  woocommerceShippingClassByID: woocommerceShippingClass(by: { id: $shippingClassId }) {
    __typename
    id
    name
    slug
    description
    count
  }
}

Questa query recupera una singola classe di spedizione tramite slug:

query FetchShippingClassBySlug($slug: String!) {
  woocommerceShippingClassBySlug: woocommerceShippingClass(by: { slug: $slug }) {
    __typename
    id
    name
    slug
    description
    count
  }
}

Aliquote fiscali

Questa query recupera tutte le aliquote fiscali:

query FetchTaxRates {
  woocommerceTaxRates {
    __typename
    id
    country
    state
    postcode
    city
    rate
    name
    priority
    compound
    shipping
    order
    class
  }
}

Questa query recupera una singola aliquota fiscale tramite ID:

query FetchTaxRate($taxRateId: ID!) {
  woocommerceTaxRate(by: { id: $taxRateId }) {
    __typename
    id
    country
    state
    postcode
    city
    rate
    name
    priority
    compound
    shipping
    order
    class
  }
}

Gateway di pagamento

Questa query recupera tutti i gateway di pagamento:

query FetchPaymentGateways {
  woocommercePaymentGateways {
    __typename
    id
    title
    description
    enabled
    methodID
    methodTitle
    methodDescription
    icon
    isAvailable
    isActive
  }
}