Admin-Product/graphql/product.resolvers.go

package graphql

import (
	"context"
	"fmt"
	"github.com/gshopify/service-wrapper/server/middleware"

	"gshopper.com/gshopify/admin-api/graph/product/generated"
)

// ProductAppendImages is the resolver for the productAppendImages field.
func (r *mutationResolver) ProductAppendImages(ctx context.Context, input generated.ProductAppendImagesInput) (*generated.ProductAppendImagesPayload, error) {
	panic(fmt.Errorf("not implemented: ProductAppendImages - productAppendImages"))
}

// ProductChangeStatus is the resolver for the productChangeStatus field.
func (r *mutationResolver) ProductChangeStatus(ctx context.Context, productID string, status generated.ProductStatus) (*generated.ProductChangeStatusPayload, error) {
	panic(fmt.Errorf("not implemented: ProductChangeStatus - productChangeStatus"))
}

// ProductCreate is the resolver for the productCreate field.
func (r *mutationResolver) ProductCreate(ctx context.Context, input generated.ProductInput, media []*generated.CreateMediaInput) (*generated.ProductCreatePayload, error) {
	panic(fmt.Errorf("not implemented: ProductCreate - productCreate"))
}

// ProductCreateMedia is the resolver for the productCreateMedia field.
func (r *mutationResolver) ProductCreateMedia(ctx context.Context, productID string, media []*generated.CreateMediaInput) (*generated.ProductCreateMediaPayload, error) {
	panic(fmt.Errorf("not implemented: ProductCreateMedia - productCreateMedia"))
}

// ProductDelete is the resolver for the productDelete field.
func (r *mutationResolver) ProductDelete(ctx context.Context, input generated.ProductDeleteInput) (*generated.ProductDeletePayload, error) {
	panic(fmt.Errorf("not implemented: ProductDelete - productDelete"))
}

// ProductDeleteImages is the resolver for the productDeleteImages field.
func (r *mutationResolver) ProductDeleteImages(ctx context.Context, id string, imageIds []string) (*generated.ProductDeleteImagesPayload, error) {
	panic(fmt.Errorf("not implemented: ProductDeleteImages - productDeleteImages"))
}

// ProductDeleteMedia is the resolver for the productDeleteMedia field.
func (r *mutationResolver) ProductDeleteMedia(ctx context.Context, productID string, mediaIds []string) (*generated.ProductDeleteMediaPayload, error) {
	panic(fmt.Errorf("not implemented: ProductDeleteMedia - productDeleteMedia"))
}

// ProductDuplicate is the resolver for the productDuplicate field.
func (r *mutationResolver) ProductDuplicate(ctx context.Context, productID string, newTitle string, newStatus *generated.ProductStatus, includeImages *bool) (*generated.ProductDuplicatePayload, error) {
	panic(fmt.Errorf("not implemented: ProductDuplicate - productDuplicate"))
}

// ProductImageUpdate is the resolver for the productImageUpdate field.
func (r *mutationResolver) ProductImageUpdate(ctx context.Context, productID string, image generated.ImageInput) (*generated.ProductImageUpdatePayload, error) {
	panic(fmt.Errorf("not implemented: ProductImageUpdate - productImageUpdate"))
}

// ProductJoinSellingPlanGroups is the resolver for the productJoinSellingPlanGroups field.
func (r *mutationResolver) ProductJoinSellingPlanGroups(ctx context.Context, id string, sellingPlanGroupIds []string) (*generated.ProductJoinSellingPlanGroupsPayload, error) {
	panic(fmt.Errorf("not implemented: ProductJoinSellingPlanGroups - productJoinSellingPlanGroups"))
}

// ProductLeaveSellingPlanGroups is the resolver for the productLeaveSellingPlanGroups field.
func (r *mutationResolver) ProductLeaveSellingPlanGroups(ctx context.Context, id string, sellingPlanGroupIds []string) (*generated.ProductLeaveSellingPlanGroupsPayload, error) {
	panic(fmt.Errorf("not implemented: ProductLeaveSellingPlanGroups - productLeaveSellingPlanGroups"))
}

// ProductReorderImages is the resolver for the productReorderImages field.
func (r *mutationResolver) ProductReorderImages(ctx context.Context, id string, moves []*generated.MoveInput) (*generated.ProductReorderImagesPayload, error) {
	panic(fmt.Errorf("not implemented: ProductReorderImages - productReorderImages"))
}

// ProductReorderMedia is the resolver for the productReorderMedia field.
func (r *mutationResolver) ProductReorderMedia(ctx context.Context, id string, moves []*generated.MoveInput) (*generated.ProductReorderMediaPayload, error) {
	panic(fmt.Errorf("not implemented: ProductReorderMedia - productReorderMedia"))
}

// ProductUpdate is the resolver for the productUpdate field.
func (r *mutationResolver) ProductUpdate(ctx context.Context, input generated.ProductInput) (*generated.ProductUpdatePayload, error) {
	panic(fmt.Errorf("not implemented: ProductUpdate - productUpdate"))
}

// ProductUpdateMedia is the resolver for the productUpdateMedia field.
func (r *mutationResolver) ProductUpdateMedia(ctx context.Context, productID string, media []*generated.UpdateMediaInput) (*generated.ProductUpdateMediaPayload, error) {
	panic(fmt.Errorf("not implemented: ProductUpdateMedia - productUpdateMedia"))
}

// ProductVariantAppendMedia is the resolver for the productVariantAppendMedia field.
func (r *mutationResolver) ProductVariantAppendMedia(ctx context.Context, productID string, variantMedia []*generated.ProductVariantAppendMediaInput) (*generated.ProductVariantAppendMediaPayload, error) {
	panic(fmt.Errorf("not implemented: ProductVariantAppendMedia - productVariantAppendMedia"))
}

// ProductVariantCreate is the resolver for the productVariantCreate field.
func (r *mutationResolver) ProductVariantCreate(ctx context.Context, input generated.ProductVariantInput) (*generated.ProductVariantCreatePayload, error) {
	panic(fmt.Errorf("not implemented: ProductVariantCreate - productVariantCreate"))
}

// ProductVariantDelete is the resolver for the productVariantDelete field.
func (r *mutationResolver) ProductVariantDelete(ctx context.Context, id string) (*generated.ProductVariantDeletePayload, error) {
	panic(fmt.Errorf("not implemented: ProductVariantDelete - productVariantDelete"))
}

// ProductVariantDetachMedia is the resolver for the productVariantDetachMedia field.
func (r *mutationResolver) ProductVariantDetachMedia(ctx context.Context, productID string, variantMedia []*generated.ProductVariantDetachMediaInput) (*generated.ProductVariantDetachMediaPayload, error) {
	panic(fmt.Errorf("not implemented: ProductVariantDetachMedia - productVariantDetachMedia"))
}

// ProductVariantJoinSellingPlanGroups is the resolver for the productVariantJoinSellingPlanGroups field.
func (r *mutationResolver) ProductVariantJoinSellingPlanGroups(ctx context.Context, id string, sellingPlanGroupIds []string) (*generated.ProductVariantJoinSellingPlanGroupsPayload, error) {
	panic(fmt.Errorf("not implemented: ProductVariantJoinSellingPlanGroups - productVariantJoinSellingPlanGroups"))
}

// ProductVariantLeaveSellingPlanGroups is the resolver for the productVariantLeaveSellingPlanGroups field.
func (r *mutationResolver) ProductVariantLeaveSellingPlanGroups(ctx context.Context, id string, sellingPlanGroupIds []string) (*generated.ProductVariantLeaveSellingPlanGroupsPayload, error) {
	panic(fmt.Errorf("not implemented: ProductVariantLeaveSellingPlanGroups - productVariantLeaveSellingPlanGroups"))
}

// ProductVariantUpdate is the resolver for the productVariantUpdate field.
func (r *mutationResolver) ProductVariantUpdate(ctx context.Context, input generated.ProductVariantInput) (*generated.ProductVariantUpdatePayload, error) {
	panic(fmt.Errorf("not implemented: ProductVariantUpdate - productVariantUpdate"))
}

// ProductVariantsBulkCreate is the resolver for the productVariantsBulkCreate field.
func (r *mutationResolver) ProductVariantsBulkCreate(ctx context.Context, variants []*generated.ProductVariantsBulkInput, productID string) (*generated.ProductVariantsBulkCreatePayload, error) {
	panic(fmt.Errorf("not implemented: ProductVariantsBulkCreate - productVariantsBulkCreate"))
}

// ProductVariantsBulkDelete is the resolver for the productVariantsBulkDelete field.
func (r *mutationResolver) ProductVariantsBulkDelete(ctx context.Context, variantsIds []string, productID string) (*generated.ProductVariantsBulkDeletePayload, error) {
	panic(fmt.Errorf("not implemented: ProductVariantsBulkDelete - productVariantsBulkDelete"))
}

// ProductVariantsBulkReorder is the resolver for the productVariantsBulkReorder field.
func (r *mutationResolver) ProductVariantsBulkReorder(ctx context.Context, productID string, positions []*generated.ProductVariantPositionInput) (*generated.ProductVariantsBulkReorderPayload, error) {
	panic(fmt.Errorf("not implemented: ProductVariantsBulkReorder - productVariantsBulkReorder"))
}

// ProductVariantsBulkUpdate is the resolver for the productVariantsBulkUpdate field.
func (r *mutationResolver) ProductVariantsBulkUpdate(ctx context.Context, variants []*generated.ProductVariantsBulkInput, productID string) (*generated.ProductVariantsBulkUpdatePayload, error) {
	panic(fmt.Errorf("not implemented: ProductVariantsBulkUpdate - productVariantsBulkUpdate"))
}

// Product is the resolver for the product field.
func (r *queryResolver) Product(ctx context.Context, id string) (*generated.Product, error) {
	var (
		inContext *middleware.GShopifyContext
		err       error
	)

	if inContext, err = middleware.InContext(ctx); err != nil {
		return nil, err
	}

	panic(inContext)
}

// ProductByHandle is the resolver for the productByHandle field.
func (r *queryResolver) ProductByHandle(ctx context.Context, handle string) (*generated.Product, error) {
	panic(fmt.Errorf("not implemented: ProductByHandle - productByHandle"))
}

// ProductResourceFeedback is the resolver for the productResourceFeedback field.
func (r *queryResolver) ProductResourceFeedback(ctx context.Context, id string) (*generated.ProductResourceFeedback, error) {
	panic(fmt.Errorf("not implemented: ProductResourceFeedback - productResourceFeedback"))
}

// ProductSavedSearches is the resolver for the productSavedSearches field.
func (r *queryResolver) ProductSavedSearches(ctx context.Context, after *string, before *string, first *int, last *int, reverse *bool) (*generated.SavedSearchConnection, error) {
	panic(fmt.Errorf("not implemented: ProductSavedSearches - productSavedSearches"))
}

// ProductVariant is the resolver for the productVariant field.
func (r *queryResolver) ProductVariant(ctx context.Context, id string) (*generated.ProductVariant, error) {
	panic(fmt.Errorf("not implemented: ProductVariant - productVariant"))
}

// ProductVariants is the resolver for the productVariants field.
func (r *queryResolver) ProductVariants(ctx context.Context, after *string, before *string, first *int, last *int, query *string, reverse *bool, savedSearchID *string, sortKey *generated.ProductVariantSortKeys) (*generated.ProductVariantConnection, error) {
	panic(fmt.Errorf("not implemented: ProductVariants - productVariants"))
}

// Products is the resolver for the products field.
func (r *queryResolver) Products(ctx context.Context, after *string, before *string, first *int, last *int, query *string, reverse *bool, savedSearchID *string, sortKey *generated.ProductSortKeys) (*generated.ProductConnection, error) {
	panic(fmt.Errorf("not implemented: Products - products"))
}

// Mutation returns generated.MutationResolver implementation.
func (r *Resolver) Mutation() generated.MutationResolver { return &mutationResolver{r} }

// Query returns generated.QueryResolver implementation.
func (r *Resolver) Query() generated.QueryResolver { return &queryResolver{r} }

type mutationResolver struct{ *Resolver }
type queryResolver struct{ *Resolver }