finding

package module
v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 25, 2022 License: GPL-3.0 Imports: 6 Imported by: 0

README

example workflow

Golang library implementation of eBay Finding API

You can check all the Finding API search options and limitations here

Example

package main

import (
	"fmt"
	"github.com/hotafrika/ebay-finding-api"
)

func main() {
	// Create Finding API service
	s := finding.NewService("your-sec-app-name").WithPageLimit(50)
	// Create findItemsAdvanced call request
	r := s.NewAdvancedRequest()
	// Set few search parameters
	r.WithDescriptionSearch(true)
	r.WithKeywords("harry potter")
	r.WithItemFilterCondition(finding.ConditionGood, finding.ConditionNew)
	r.WithItemFilterMaxPriceWithCurrency(100, finding.CurrencyIDUSD)
	r.WithSortOrder(finding.SortOrderCurrentPriceHighest)
	r.WithPageLimit(1)
	r.WithOutputSelectors(finding.OutputSelectorAspectHistogram,
		finding.OutputSelectorSellerInfo,
		finding.OutputSelectorStoreInfo,
		finding.OutputSelectorUnitPriceInfo,
		finding.OutputSelectorGalleryInfo,
		finding.OutputSelectorPictureURLSuperSize,
		finding.OutputSelectorConditionHistogram,
		finding.OutputSelectorCategoryHistogram,
		finding.OutputSelectorPictureURLLarge)
	// Get first page
	res, err := r.Execute()
	if err != nil {
		panic(err)
	}
	fmt.Printf("%+v", res)
	// Get second page
	res2, err := r.GetPage(2)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%+v", res2)
}

Documentation

Index

Constants

View Source 
const (
	// EbayEndpointProduction is a production endpoint for Finding API
	EbayEndpointProduction = "https://svcs.ebay.com/services/search/FindingService/v1"
	// EbayEndpointSandbox is a sandbox endpoint for Finding API
	EbayEndpointSandbox = "https://svcs.sandbox.ebay.com/services/search/FindingService/v1"
)
View Source 
const DefaultItemsPerPage = 100
View Source 
const EbayFindingAPIVersion = "1.13.0"
View Source 
const EbayFindingNamespace = "http://www.ebay.com/marketplace/search/v1/services"
View Source 
const EbayRequestDataFormat = "XML"
View Source 
const EbayResponseDataFormat = "XML"
View Source 
const EbayServiceName = "FindingService"

Variables

View Source 
var UTC, _ = time.LoadLocation("UTC")

Functions

func FromEbayDateTime 

func FromEbayDateTime(ebayDT string) (time.Time, error)

FromEbayDateTime converts eBay datetime format to time.Time By default eBay date-time values are recorded in Universal Coordinated Time (UTC)

func FromEbayDuration 

func FromEbayDuration(ebayDuration string) time.Duration

FromEbayDuration converts eBay duration to Golang duration eBay format is PnYnMnDTnHnMnS (e.g., P2DT23H32M51S)

func ToEbayDateTime 

func ToEbayDateTime(datetime time.Time) string

ToEbayDateTime converts given time to eBay format Given datetime has to be casted to UTC location.

Types

type AdvancedRequest 

type AdvancedRequest struct {
	XMLName xml.Name `xml:"http://www.ebay.com/marketplace/search/v1/services findItemsAdvancedRequest" json:"-"`
	RequestCategories
	RequestKeywords
	RequestDescriptionSearch
	RequestAspectFilter
	RequestItemFilter
	RequestOutputSelector
	RequestStandard
}

AdvancedRequest searches for items on eBay by category or keyword or both.

func (*AdvancedRequest) Execute 

func (sr *AdvancedRequest) Execute() (AdvancedResponse, error)

Execute executes AdvancedRequest for the first page

func (*AdvancedRequest) GetBody 

func (sr *AdvancedRequest) GetBody() ([]byte, error)

GetBody return AdvancedRequest body as XML

func (*AdvancedRequest) GetPage 

func (sr *AdvancedRequest) GetPage(page int) (AdvancedResponse, error)

GetPage executes AdvancedRequest for page # Valid pages # 1 - 100

type AdvancedResponse 

type AdvancedResponse struct {
	XMLName xml.Name `xml:"findItemsAdvancedResponse"`
	ResponseAspectHistogramContainer
	ResponseCategoryHistogramContainer
	ResponseConditionHistogramContainer

	// ItemSearchURL is a URL to view the search results on the eBay web site.
	// The search results on the web site will use the same pagination as the API search results.
	ItemSearchURL string `xml:"itemSearchURL"`
	ResponsePaginationOutput
	ResponseSearchResult
	// contains filtered or unexported fields
}

AdvancedResponse represents findItemsAdvancedResponse

type Aspect 

type Aspect struct {
	Name            string           `xml:"name,attr"`
	ValueHistograms []ValueHistogram `xml:"valueHistogram"`
}

Aspect is a characteristic of an item in a domain.

type AspectHistogramContainer 

type AspectHistogramContainer struct {
	Aspects           []Aspect `xml:"aspect"`
	DomainDisplayName string   `xml:"domainDisplayName"`
	DomainName        string   `xml:"domainName"`
}

AspectHistogramContainer is response container for aspect histograms.

type AspectNameParameter 

type AspectNameParameter string

type ByCategoryRequest 

type ByCategoryRequest struct {
	XMLName xml.Name `xml:"http://www.ebay.com/marketplace/search/v1/services findItemsByCategoryRequest" json:"-"`
	RequestCategories
	RequestAspectFilter
	RequestItemFilter
	RequestOutputSelector
	RequestStandard
}

ByCategoryRequest searches for items on eBay using specific eBay category ID numbers (input category ID numbers using categoryId).

func (*ByCategoryRequest) Execute 

func (sr *ByCategoryRequest) Execute() (ByCategoryResponse, error)

Execute executes ByCategoryRequest for the first page

func (*ByCategoryRequest) GetBody 

func (sr *ByCategoryRequest) GetBody() ([]byte, error)

GetBody return ByCategoryRequest body as XML

func (*ByCategoryRequest) GetPage 

func (sr *ByCategoryRequest) GetPage(page int) (ByCategoryResponse, error)

GetPage executes ByCategoryRequest for page # Valid pages # 1 - 100

type ByCategoryResponse 

type ByCategoryResponse struct {
	XMLName xml.Name `xml:"findItemsByCategoryResponse"`
	ResponseAspectHistogramContainer
	ResponseCategoryHistogramContainer
	ResponseConditionHistogramContainer

	// ItemSearchURL is a URL to view the search results on the eBay web site.
	// The search results on the web site will use the same pagination as the API search results.
	ItemSearchURL string `xml:"itemSearchURL"`
	ResponsePaginationOutput
	ResponseSearchResult
	// contains filtered or unexported fields
}

ByCategoryResponse represents findItemsByCategoryResponse

type ByKeywordsRequest 

type ByKeywordsRequest struct {
	XMLName xml.Name `xml:"http://www.ebay.com/marketplace/search/v1/services findItemsByKeywordsRequest" json:"-"`
	RequestKeywords
	RequestDescriptionSearch
	RequestAspectFilter
	RequestItemFilter
	RequestOutputSelector
	RequestStandard
}

ByKeywordsRequest searches for items on eBay by a keyword query (keywords).

func (*ByKeywordsRequest) Execute 

func (sr *ByKeywordsRequest) Execute() (ByKeywordsResponse, error)

Execute executes ByKeywordsRequest for the first page

func (*ByKeywordsRequest) GetBody 

func (sr *ByKeywordsRequest) GetBody() ([]byte, error)

GetBody return ByKeywordsRequest body as XML

func (*ByKeywordsRequest) GetPage 

func (sr *ByKeywordsRequest) GetPage(page int) (ByKeywordsResponse, error)

GetPage executes ByKeywordsRequest for page # Valid pages # 1 - 100

type ByKeywordsResponse 

type ByKeywordsResponse struct {
	XMLName xml.Name `xml:"findItemsByKeywordsResponse"`
	ResponseAspectHistogramContainer
	ResponseCategoryHistogramContainer
	ResponseConditionHistogramContainer

	// ItemSearchURL is a URL to view the search results on the eBay web site.
	// The search results on the web site will use the same pagination as the API search results.
	ItemSearchURL string `xml:"itemSearchURL"`
	PaginationOutput
	ResponseSearchResult
	// contains filtered or unexported fields
}

ByKeywordsResponse represents findItemsByKeywordsResponse

type ByProductRequest 

type ByProductRequest struct {
	XMLName xml.Name `xml:"http://www.ebay.com/marketplace/search/v1/services findItemsByProductRequest" json:"-"`
	RequestProduct
	RequestItemFilter
	RequestOutputSelector
	RequestStandard
}

ByProductRequest searches for items on eBay using specific eBay product values.

func (*ByProductRequest) Execute 

func (sr *ByProductRequest) Execute() (ByProductResponse, error)

Execute executes ByProductRequest for the first page

func (*ByProductRequest) GetBody 

func (sr *ByProductRequest) GetBody() ([]byte, error)

GetBody return ByProductRequest body as XML

func (*ByProductRequest) GetPage 

func (sr *ByProductRequest) GetPage(page int) (ByProductResponse, error)

GetPage executes ByProductRequest for page # Valid pages # 1 - 100

type ByProductResponse 

type ByProductResponse struct {
	XMLName xml.Name `xml:"findItemsByProductResponse"`
	ResponseAspectHistogramContainer
	ResponseConditionHistogramContainer

	// ItemSearchURL is a URL to view the search results on the eBay web site.
	// The search results on the web site will use the same pagination as the API search results.
	ItemSearchURL string `xml:"itemSearchURL"`
	ResponsePaginationOutput
	ResponseSearchResult
	// contains filtered or unexported fields
}

ByProductResponse represents findItemsByProductResponse

type Category 

type Category struct {
	CategoryId   string `xml:"categoryId"`
	CategoryName string `xml:"categoryName"`
}

type CategoryHistogram 

type CategoryHistogram struct {
	CategoryId              string              `xml:"categoryId"`
	CategoryName            string              `xml:"categoryName"`
	ChildCategoryHistograms []CategoryHistogram `xml:"childCategoryHistogram"`
	Count                   int64               `xml:"count"`
}

CategoryHistogram Statistical (item count) information on the categories that contain items that match the search criteria or specified category or categories. A category histogram contains information for up to 10 child categories. Search result total entries may not necessarily match the sum of category histogram item counts.

type CategoryHistogramContainer 

type CategoryHistogramContainer struct {
	CategoryHistograms []CategoryHistogram `xml:"categoryHistogram"`
}

CategoryHistogramContainer is a response container for category histograms. Only returned when one or more category histograms are returned. A category histogram is not returned if there are no matching items or if the search is restricted to a single leaf category.

type Condition 

type Condition struct {
	ConditionDisplayName string `xml:"conditionDisplayName"`
	ConditionId          string `xml:"conditionId"`
}

type ConditionHistogram 

type ConditionHistogram struct {
	Condition Condition `xml:"condition"`
	Count     int       `xml:"count"`
}

ConditionHistogram Statistical (item count) information on the condition of items that match the search criteria (or specified category). For example, the number of brand new items that match the query.

type ConditionHistogramContainer 

type ConditionHistogramContainer struct {
	ConditionHistograms []ConditionHistogram `xml:"conditionHistogram"`
}

ConditionHistogramContainer is a response container for condition histograms. Not returned when Condition is specified in itemFilter. That is, only returned when you have not yet narrowed your search based on specific conditions.

type DiscountPriceInfo 

type DiscountPriceInfo struct {
	MinimumAdvertisedPriceExposure string  `xml:"minimumAdvertisedPriceExposure"`
	OriginalRetailPrice            float64 `xml:"originalRetailPrice"`
	PricingTreatment               string  `xml:"pricingTreatment"`
	SoldOffEbay                    bool    `xml:"soldOffEbay"`
	SoldOnEbay                     bool    `xml:"soldOnEbay"`
}

type Distance added in v0.2.0 

type Distance struct {
	Value float64 `xml:",cdata"`
	Unit  string  `xml:"unit,attr"`
}

type EbayEndpoint 

type EbayEndpoint string

type EbayOperation 

type EbayOperation string
const (
	OperationFindItemsAdvanced               EbayOperation = "findItemsAdvanced"
	OperationFindItemsByCategory             EbayOperation = "findItemsByCategory"
	OperationFindItemsByKeywords             EbayOperation = "findItemsByKeywords"
	OperationFindItemsByProduct              EbayOperation = "findItemsByProduct"
	OperationFindItemsIneBayStores           EbayOperation = "findItemsIneBayStores"
	OperationGetSearchKeywordsRecommendation EbayOperation = "getSearchKeywordsRecommendation"
	OperationGetHistograms                   EbayOperation = "getHistograms"
	OperationGetVersion                      EbayOperation = "getVersion"
)

type Error 

type Error struct {
	Category    string      `xml:"category"`
	Domain      string      `xml:"domain"`
	ErrorID     string      `xml:"errorId"`
	ExceptionID string      `xml:"exceptionId"`
	Message     string      `xml:"message"`
	Parameters  []Parameter `xml:"parameter"`
	Severity    string      `xml:"severity"`
	Subdomain   string      `xml:"subdomain"`
}

type GalleryURL added in v0.2.0 

type GalleryURL struct {
	URL  string `xml:",cdata"`
	Size string `xml:"gallerySize,attr"`
}

type GetHistogramsRequest 

type GetHistogramsRequest struct {
	XMLName    xml.Name `xml:"http://www.ebay.com/marketplace/search/v1/services getHistogramsRequest" json:"-"`
	CategoryId string   `json:"categoryId" xml:"categoryId"`
	RequestBasic
}

GetHistogramsRequest retrieves category and/or aspect histogram information for the eBay category you specify using the categoryId field.

func (*GetHistogramsRequest) Execute 

func (sr *GetHistogramsRequest) Execute() (GetHistogramsResponse, error)

Execute executes GetHistogramsRequest

func (*GetHistogramsRequest) GetBody 

func (sr *GetHistogramsRequest) GetBody() ([]byte, error)

GetBody return GetHistogramsRequest body as XML

func (*GetHistogramsRequest) WithCategory 

func (sr *GetHistogramsRequest) WithCategory(category string) *GetHistogramsRequest

WithCategory adds categoryId to GetHistogramsRequest

type GetHistogramsResponse 

type GetHistogramsResponse struct {
	XMLName xml.Name `xml:"getHistogramsResponse"`
	// contains filtered or unexported fields
}

GetHistogramsResponse represents getHistogramsResponse

type GetKeywordsRecommendationRequest 

type GetKeywordsRecommendationRequest struct {
	XMLName xml.Name `xml:"http://www.ebay.com/marketplace/search/v1/services getSearchKeywordsRecommendationRequest" json:"-"`
	RequestKeywords
	RequestBasic
}

GetKeywordsRecommendationRequest retrieves commonly used words found in eBay titles, based on the words you supply to the call.

func (*GetKeywordsRecommendationRequest) Execute 

func (sr *GetKeywordsRecommendationRequest) Execute() (GetKeywordsRecommendationResponse, error)

Execute executes GetKeywordsRecommendationRequest

func (*GetKeywordsRecommendationRequest) GetBody 

func (sr *GetKeywordsRecommendationRequest) GetBody() ([]byte, error)

GetBody return GetKeywordsRecommendationRequest body as XML

type GetKeywordsRecommendationResponse 

type GetKeywordsRecommendationResponse struct {
	XMLName  xml.Name `xml:"getSearchKeywordsRecommendationResponse"`
	Keywords string   `xml:"keywords"`
	// contains filtered or unexported fields
}

GetKeywordsRecommendationResponse represents getSearchKeywordsRecommendationResponse

type GetVersionRequest 

type GetVersionRequest struct {
	XMLName xml.Name `xml:"http://www.ebay.com/marketplace/search/v1/services getVersionRequest" json:"-"`
	RequestBasic
}

GetVersionRequest returns the current version of the service. This simple call can be used to monitor the service for availability. This call has no input parameters and the response contains only the standard output fields.

func (*GetVersionRequest) Execute 

func (sr *GetVersionRequest) Execute() (GetVersionResponse, error)

Execute executes GetVersionRequest

func (*GetVersionRequest) GetBody added in v0.2.0 

func (sr *GetVersionRequest) GetBody() ([]byte, error)

GetBody return GetVersionRequest body as XML

type GetVersionResponse 

type GetVersionResponse struct {
	XMLName xml.Name `xml:"getVersionResponse"`
	// contains filtered or unexported fields
}

GetVersionResponse represents getVersionResponse

type GlobalID 

type GlobalID string
const (
	GlobalIDEbayUS    GlobalID = "EBAY-US"
	GlobalIDEbayENCA  GlobalID = "EBAY-ENCA"
	GlobalIDEbayGB    GlobalID = "EBAY-GB"
	GlobalIDEbayAU    GlobalID = "EBAY-AU"
	GlobalIDEbayAT    GlobalID = "EBAY-AT"
	GlobalIDEbayFRBE  GlobalID = "EBAY-FRBE"
	GlobalIDEbayFR    GlobalID = "EBAY-FR"
	GlobalIDEbayDE    GlobalID = "EBAY-DE"
	GlobalIDEbayMOTOR GlobalID = "EBAY-MOTOR"
	GlobalIDEbayIT    GlobalID = "EBAY-IT"
	GlobalIDEbayNLBE  GlobalID = "EBAY-NLBE"
	GlobalIDEbayNL    GlobalID = "EBAY-NL"
	GlobalIDEbayES    GlobalID = "EBAY-ES"
	GlobalIDEbayCH    GlobalID = "EBAY-CH"
	GlobalIDEbayHK    GlobalID = "EBAY-HK"
	GlobalIDEbayIN    GlobalID = "EBAY-IN"
	GlobalIDEbayIE    GlobalID = "EBAY-IE"
	GlobalIDEbayMY    GlobalID = "EBAY-MY"
	GlobalIDEbayFRCA  GlobalID = "EBAY-FRCA"
	GlobalIDEbayPH    GlobalID = "EBAY-PH"
	GlobalIDEbaySG    GlobalID = "EBAY-SG"
)

type InEbayStoresRequest 

type InEbayStoresRequest struct {
	XMLName   xml.Name `xml:"http://www.ebay.com/marketplace/search/v1/services findItemsIneBayStoresRequest" json:"-"`
	StoreName string   `json:"storeName,omitempty" xml:"storeName,omitempty"`
	RequestAspectFilter
	RequestCategories
	RequestKeywords
	RequestItemFilter
	RequestOutputSelector
	RequestStandard
}

InEbayStoresRequest searches for items in the eBay store inventories. You can combine storeName with keywords to find specific items, or use keywords without storeName to search for items in all eBay stores.

func (*InEbayStoresRequest) Execute 

func (sr *InEbayStoresRequest) Execute() (InEbayStoresResponse, error)

Execute executes InEbayStoresRequest for the first page

func (*InEbayStoresRequest) GetBody 

func (sr *InEbayStoresRequest) GetBody() ([]byte, error)

GetBody return InEbayStoresRequest body as XML

func (*InEbayStoresRequest) GetPage 

func (sr *InEbayStoresRequest) GetPage(page int) (InEbayStoresResponse, error)

GetPage executes InEbayStoresRequest for page # Valid pages # 1 - 100

func (*InEbayStoresRequest) WithStoreName 

func (sr *InEbayStoresRequest) WithStoreName(name string) *InEbayStoresRequest

WithStoreName adds store's name to InEbayStoresRequest

type InEbayStoresResponse 

type InEbayStoresResponse struct {
	XMLName xml.Name `xml:"findItemsIneBayStoresResponse"`
	ResponseAspectHistogramContainer
	ResponseCategoryHistogramContainer
	ResponseConditionHistogramContainer

	// ItemSearchURL is a URL to view the search results on the eBay web site.
	// The search results on the web site will use the same pagination as the API search results.
	ItemSearchURL string `xml:"itemSearchURL"`
	ResponsePaginationOutput
	ResponseSearchResult
	// contains filtered or unexported fields
}

InEbayStoresResponse represents findItemsIneBayStoresResponse

type Item 

type Item struct {
	Attributes              []ItemAttribute   `xml:"attribute"`
	CharityID               string            `xml:"charityId"`
	Compatibility           string            `xml:"compatibility"`
	Condition               Condition         `xml:"condition"`
	Country                 string            `xml:"country"`
	DiscountPriceInfo       DiscountPriceInfo `xml:"discountPriceInfo"`
	Distance                Distance          `xml:"distance"`
	EekStatuses             []string          `xml:"eekStatus"`
	GalleryInfoContainer    []GalleryURL      `xml:"galleryInfoContainer>galleryURL"`
	GalleryPlusPictureURLs  []string          `xml:"galleryPlusPictureURL"`
	GalleryURL              string            `xml:"galleryURL"`
	GlobalID                string            `xml:"globalId"`
	ItemID                  string            `xml:"itemId"`
	ListingInfo             ListingInfo       `xml:"listingInfo"`
	Location                string            `xml:"location"`
	PaymentMethods          []string          `xml:"paymentMethod"`
	PictureURLLarge         string            `xml:"pictureURLLarge"`
	PictureURLSuperSize     string            `xml:"pictureURLSuperSize"`
	PostalCode              string            `xml:"postalCode"`
	PrimaryCategory         Category          `xml:"primaryCategory"`
	ProductID               string            `xml:"productId"`
	SecondaryCategory       Category          `xml:"secondaryCategory"`
	SellerInfo              SellerInfo        `xml:"sellerInfo"`
	SellingStatus           SellingStatus     `xml:"sellingStatus"`
	ShippingInfo            ShippingInfo      `xml:"shippingInfo"`
	StoreInfo               StoreInfo         `xml:"storeInfo"`
	Subtitle                string            `xml:"subtitle"`
	Title                   string            `xml:"title"`
	UnitPrice               UnitPriceInfo     `xml:"unitPrice"`
	ViewItemURL             string            `xml:"viewItemURL"`
	AutoPay                 bool              `xml:"autoPay"`
	EbayPlusEnabled         bool              `xml:"eBayPlusEnabled"`
	ReturnsAccepted         bool              `xml:"returnsAccepted"`
	TopRatedListing         bool              `xml:"topRatedListing"`
	IsMultiVariationListing bool              `xml:"isMultiVariationListing"`
}

Item is a container for the data of a single item that matches the search criteria.

type ItemAttribute 

type ItemAttribute struct {
	Name  string `xml:"name"`
	Value string `xml:"value"`
}

type ItemFilterConditionNameOption added in v0.2.0 

type ItemFilterConditionNameOption string
const (
	ConditionNameNew                  ItemFilterConditionNameOption = "New"
	ConditionNameNewOther             ItemFilterConditionNameOption = "New other (see details)"
	ConditionNameNewWithDefects       ItemFilterConditionNameOption = "New with defects"
	ConditionNameCertifiedRefurbished ItemFilterConditionNameOption = "Certified refurbished"
	// ConditionNameExcellentRefurbished is used in Cell Phones & Smartphones category (9355)
	// on the US, Canada, UK, Germany, and Australia
	ConditionNameExcellentRefurbished ItemFilterConditionNameOption = "Excellent - Refurbished"
	// ConditionNameVeryGoodRefurbished is used in Cell Phones & Smartphones category (9355)
	// on the US, Canada, UK, Germany, and Australia
	ConditionNameVeryGoodRefurbished ItemFilterConditionNameOption = "Very Good - Refurbished"
	// ConditionNameGoodRefurbished is used in Cell Phones & Smartphones category (9355)
	// on the US, Canada, UK, Germany, and Australia
	ConditionNameGoodRefurbished ItemFilterConditionNameOption = "Good - Refurbished"
	// ConditionNameSellerRefurbished can't be used in Cell Phones & Smartphones category (9355)
	// on the US, Canada, UK, Germany, and Australia
	ConditionNameSellerRefurbished    ItemFilterConditionNameOption = "Seller refurbished"
	ConditionNameLikeNew              ItemFilterConditionNameOption = "Like New"
	ConditionNameUsed                 ItemFilterConditionNameOption = "Used"
	ConditionNameVeryGood             ItemFilterConditionNameOption = "Very Good"
	ConditionNameGood                 ItemFilterConditionNameOption = "Good"
	ConditionNameAcceptable           ItemFilterConditionNameOption = "Acceptable"
	ConditionNameForPartsOrNotWorking ItemFilterConditionNameOption = "For parts or not working"
)

type ItemFilterConditionOption 

type ItemFilterConditionOption string
const (
	ConditionNew                  ItemFilterConditionOption = "1000"
	ConditionNewOther             ItemFilterConditionOption = "1500"
	ConditionNewWithDefects       ItemFilterConditionOption = "1750"
	ConditionCertifiedRefurbished ItemFilterConditionOption = "2000"
	// ConditionExcellentRefurbished is used in Cell Phones & Smartphones category (9355)
	// on the US, Canada, UK, Germany, and Australia
	ConditionExcellentRefurbished ItemFilterConditionOption = "2010"
	// ConditionVeryGoodRefurbished is used in Cell Phones & Smartphones category (9355)
	// on the US, Canada, UK, Germany, and Australia
	ConditionVeryGoodRefurbished ItemFilterConditionOption = "2020"
	// ConditionGoodRefurbished is used in Cell Phones & Smartphones category (9355)
	// on the US, Canada, UK, Germany, and Australia
	ConditionGoodRefurbished ItemFilterConditionOption = "2030"
	// ConditionSellerRefurbished can't be used in Cell Phones & Smartphones category (9355)
	// on the US, Canada, UK, Germany, and Australia
	ConditionSellerRefurbished    ItemFilterConditionOption = "2500"
	ConditionLikeNew              ItemFilterConditionOption = "2750"
	ConditionUsed                 ItemFilterConditionOption = "3000"
	ConditionVeryGood             ItemFilterConditionOption = "4000"
	ConditionGood                 ItemFilterConditionOption = "5000"
	ConditionAcceptable           ItemFilterConditionOption = "6000"
	ConditionForPartsOrNotWorking ItemFilterConditionOption = "7000"
)

type ItemFilterCurrencyIDOption 

type ItemFilterCurrencyIDOption string
const (
	CurrencyIDAUD ItemFilterCurrencyIDOption = "AUD"
	CurrencyIDCAD ItemFilterCurrencyIDOption = "CAD"
	CurrencyIDCHF ItemFilterCurrencyIDOption = "CHF"
	CurrencyIDCNY ItemFilterCurrencyIDOption = "CNY"
	CurrencyIDEUR ItemFilterCurrencyIDOption = "EUR"
	CurrencyIDGBP ItemFilterCurrencyIDOption = "GBP"
	CurrencyIDHKD ItemFilterCurrencyIDOption = "HKD"
	CurrencyIDINR ItemFilterCurrencyIDOption = "INR"
	CurrencyIDMYR ItemFilterCurrencyIDOption = "MYR"
	CurrencyIDPHP ItemFilterCurrencyIDOption = "PHP"
	CurrencyIDPLN ItemFilterCurrencyIDOption = "PLN"
	CurrencyIDSEK ItemFilterCurrencyIDOption = "SEK"
	CurrencyIDSGD ItemFilterCurrencyIDOption = "SGD"
	CurrencyIDTWD ItemFilterCurrencyIDOption = "TWD"
	// CurrencyIDUSD is US Dollar.
	// For eBay, you can only specify this currency for listings you submit to the US (site ID 0), eBayMotors (site 100), and Canada (site 2) sites.
	CurrencyIDUSD ItemFilterCurrencyIDOption = "USD"
)

type ItemFilterExpeditedShippingTypeOption 

type ItemFilterExpeditedShippingTypeOption string
const (
	ExpeditedShippingTypeExpedited      ItemFilterExpeditedShippingTypeOption = "Expedited"
	ExpeditedShippingTypeOneDayShipping ItemFilterExpeditedShippingTypeOption = "OneDayShipping"
)

type ItemFilterListingTypeOption 

type ItemFilterListingTypeOption string
const (
	ListingTypeAuction        ItemFilterListingTypeOption = "Auction"
	ListingTypeAuctionWithBIN ItemFilterListingTypeOption = "AuctionWithBIN"
	ListingTypeClassified     ItemFilterListingTypeOption = "Classified"
	ListingTypeFixedPrice     ItemFilterListingTypeOption = "FixedPrice"
	ListingTypeStoreInventory ItemFilterListingTypeOption = "StoreInventory"
	ListingTypeAll            ItemFilterListingTypeOption = "All"
)

type ItemFilterParameter 

type ItemFilterParameter string
const (
	ItemFilterAuthorizedSellerOnly  ItemFilterParameter = "AuthorizedSellerOnly"
	ItemFilterAvailableTo           ItemFilterParameter = "AvailableTo"
	ItemFilterBestOfferOnly         ItemFilterParameter = "BestOfferOnly"
	ItemFilterCharityOnly           ItemFilterParameter = "CharityOnly"
	ItemFilterCondition             ItemFilterParameter = "Condition"
	ItemFilterCurrency              ItemFilterParameter = "Currency"
	ItemFilterEndTimeFrom           ItemFilterParameter = "EndTimeFrom"
	ItemFilterEndTimeTo             ItemFilterParameter = "EndTimeTo"
	ItemFilterExcludeAutoPay        ItemFilterParameter = "ExcludeAutoPay"
	ItemFilterExcludeCategory       ItemFilterParameter = "ExcludeCategory"
	ItemFilterExcludeSeller         ItemFilterParameter = "ExcludeSeller"
	ItemFilterExpeditedShippingType ItemFilterParameter = "ExpeditedShippingType"
	ItemFilterFeaturedOnly          ItemFilterParameter = "FeaturedOnly"
	ItemFilterFeedbackScoreMax      ItemFilterParameter = "FeedbackScoreMax"
	ItemFilterFeedbackScoreMin      ItemFilterParameter = "FeedbackScoreMin"
	ItemFilterFreeShippingOnly      ItemFilterParameter = "FreeShippingOnly"
	ItemFilterGetItFastOnly         ItemFilterParameter = "GetItFastOnly"
	ItemFilterHideDuplicateItems    ItemFilterParameter = "HideDuplicateItems"
	ItemFilterListedIn              ItemFilterParameter = "ListedIn"
	ItemFilterListingType           ItemFilterParameter = "ListingType"
	ItemFilterLocalPickupOnly       ItemFilterParameter = "LocalPickupOnly"
	ItemFilterLocalSearchOnly       ItemFilterParameter = "LocalSearchOnly"
	ItemFilterLocatedIn             ItemFilterParameter = "LocatedIn"
	ItemFilterLotsOnly              ItemFilterParameter = "LotsOnly"
	ItemFilterMaxBids               ItemFilterParameter = "MaxBids"
	ItemFilterMaxDistance           ItemFilterParameter = "MaxDistance"
	ItemFilterMaxHandlingTime       ItemFilterParameter = "MaxHandlingTime"
	ItemFilterMaxPrice              ItemFilterParameter = "MaxPrice"
	ItemFilterMaxQuantity           ItemFilterParameter = "MaxQuantity"
	ItemFilterMinBids               ItemFilterParameter = "MinBids"
	ItemFilterMinPrice              ItemFilterParameter = "MinPrice"
	ItemFilterMinQuantity           ItemFilterParameter = "MinQuantity"
	ItemFilterModTimeFrom           ItemFilterParameter = "ModTimeFrom"
	ItemFilterOutletSellerOnly      ItemFilterParameter = "OutletSellerOnly"
	ItemFilterPaymentMethod         ItemFilterParameter = "PaymentMethod"
	ItemFilterReturnsAcceptedOnly   ItemFilterParameter = "ReturnsAcceptedOnly"
	ItemFilterSeller                ItemFilterParameter = "Seller"
	ItemFilterSellerBusinessType    ItemFilterParameter = "SellerBusinessType"
	ItemFilterSoldItemsOnly         ItemFilterParameter = "SoldItemsOnly"
	ItemFilterStartTimeFrom         ItemFilterParameter = "StartTimeFrom"
	ItemFilterStartTimeTo           ItemFilterParameter = "StartTimeTo"
	ItemFilterTopRatedSellerOnly    ItemFilterParameter = "TopRatedSellerOnly"
	ItemFilterValueBoxInventory     ItemFilterParameter = "ValueBoxInventory"
	ItemFilterWorldOfGoodOnly       ItemFilterParameter = "WorldOfGoodOnly"
)

type ItemFilterPaymentMethodOption 

type ItemFilterPaymentMethodOption string
const (
	PaymentMethodPayPal      ItemFilterPaymentMethodOption = "PayPal"
	PaymentMethodPaisaPay    ItemFilterPaymentMethodOption = "PaisaPay"
	PaymentMethodPaisaPayEMI ItemFilterPaymentMethodOption = "PaisaPayEMI"
)

type ItemFilterSellerBusinessTypeOption 

type ItemFilterSellerBusinessTypeOption string
const (
	SellerBusinessTypeBusiness ItemFilterSellerBusinessTypeOption = "Business"
	SellerBusinessTypePrivate  ItemFilterSellerBusinessTypeOption = "Private"
)

type ListingInfo 

type ListingInfo struct {
	BestOfferEnabled       bool   `xml:"bestOfferEnabled"`
	BuyItNowAvailable      bool   `xml:"buyItNowAvailable"`
	Gift                   bool   `xml:"gift"`
	BuyItNowPrice          Price  `xml:"buyItNowPrice"`
	ConvertedBuyItNowPrice Price  `xml:"convertedBuyItNowPrice"`
	EndTime                string `xml:"endTime"`
	ListingType            string `xml:"listingType"`
	StartTime              string `xml:"startTime"`
	WatchCount             int    `xml:"watchCount"`
}

type OutputSelectorParameter 

type OutputSelectorParameter string
const (
	OutputSelectorAspectHistogram     OutputSelectorParameter = "AspectHistogram"
	OutputSelectorCategoryHistogram   OutputSelectorParameter = "CategoryHistogram"
	OutputSelectorConditionHistogram  OutputSelectorParameter = "ConditionHistogram"
	OutputSelectorGalleryInfo         OutputSelectorParameter = "GalleryInfo"
	OutputSelectorPictureURLLarge     OutputSelectorParameter = "PictureURLLarge"
	OutputSelectorPictureURLSuperSize OutputSelectorParameter = "PictureURLSuperSize"
	OutputSelectorSellerInfo          OutputSelectorParameter = "SellerInfo"
	OutputSelectorStoreInfo           OutputSelectorParameter = "StoreInfo"
	OutputSelectorUnitPriceInfo       OutputSelectorParameter = "UnitPriceInfo"
)

type PaginationOutput 

type PaginationOutput struct {
	PageNumber     int `xml:"pageNumber"`
	EntriesPerPage int `xml:"entriesPerPage"`
	TotalPages     int `xml:"totalPages"`
	TotalEntries   int `xml:"totalEntries"`
}

PaginationOutput Indicates the pagination of the result set. Child elements indicate the page number that is returned, the maximum number of item listings to return per page, total number of pages that can be returned, and the total number of listings that match the search criteria.

type Parameter 

type Parameter struct {
	Name  string `xml:"name,attr"`
	Value string `xml:",chardata"`
}

type Price 

type Price struct {
	Value      float64 `xml:",cdata"`
	CurrencyID string  `xml:"currencyId,attr"`
}

type Product 

type Product struct {
	Type string `json:"type" xml:"type,attr"`
	Text string `json:"#text" xml:",cdata"`
}

Product ...

type ProductTypeOption 

type ProductTypeOption string
const (
	ProductTypeISBN        ProductTypeOption = "ISBN"
	ProductTypeUPC         ProductTypeOption = "UPC"
	ProductTypeEAN         ProductTypeOption = "EAN"
	ProductTypeReferenceID ProductTypeOption = "ReferenceID"
)

type RequestAspectFilter 

type RequestAspectFilter struct {
	AspectFilter []ServiceAspectFilter `json:"aspectFilter,omitempty" xml:"aspectFilter,omitempty"` // removed
}

RequestAspectFilter represents AspectFilter part of ebay Finding requests

func (*RequestAspectFilter) WithAspectFilter added in v0.2.0 

func (sr *RequestAspectFilter) WithAspectFilter(aspectName string, aspectValues ...string) *RequestAspectFilter

WithAspectFilter adds AspectFilter to requests

type RequestBasic 

type RequestBasic struct {
	URL    string        `json:"-" xml:"-"`
	Client *resty.Client `json:"-" xml:"-"`
}

RequestBasic is used for requests without pages

type RequestCategories 

type RequestCategories struct {
	CategoryID []string `json:"categoryId,omitempty" xml:"categoryId,omitempty"`
}

RequestCategories represents filter by categories in ebay Finding requests

func (*RequestCategories) WithCategoriesID 

func (sr *RequestCategories) WithCategoriesID(categoriesID ...string) *RequestCategories

WithCategoriesID adds categories for searching (up to 3 categories) 

4th and next categoryIDs will be skipped silently

func (*RequestCategories) WithCategoryID 

func (sr *RequestCategories) WithCategoryID(categoryID string) *RequestCategories

WithCategoryID adds category for searching (up to 3 categories) 

4th and next categoryIDs will be skipped silently

func (*RequestCategories) WithCategoryIDInt 

func (sr *RequestCategories) WithCategoryIDInt(categoryID int) *RequestCategories

WithCategoryIDInt adds category for searching (up to 3 categories) 

4th and next categoryIDs will be skipped silently

type RequestDescriptionSearch 

type RequestDescriptionSearch struct {
	DescriptionSearch bool `json:"descriptionSearch,omitempty" xml:"descriptionSearch,omitempty"`
}

RequestDescriptionSearch represents filter by description search in ebay Finding requests

func (*RequestDescriptionSearch) WithDescriptionSearch 

func (sr *RequestDescriptionSearch) WithDescriptionSearch(ds bool) *RequestDescriptionSearch

WithDescriptionSearch specifies whether your keyword query should be applied to item descriptions in addition to titles

type RequestItemFilter 

type RequestItemFilter struct {
	ItemFilterMap map[ItemFilterParameter]ServiceItemFilter `json:"-" xml:"-"`
	ItemFilter    []ServiceItemFilter                       `json:"itemFilter,omitempty" xml:"itemFilter,omitempty"`
}

RequestItemFilter works with ItemFilter ebay entity

func (*RequestItemFilter) Initialize 

func (sr *RequestItemFilter) Initialize()

Initialize needed to initialize map inside RequestItemFilter

func (*RequestItemFilter) Reload 

func (sr *RequestItemFilter) Reload()

Reload refreshes itemFilter

func (*RequestItemFilter) WithItemFilterAuthorizedSellerOnly 

func (sr *RequestItemFilter) WithItemFilterAuthorizedSellerOnly(b bool) *RequestItemFilter

WithItemFilterAuthorizedSellerOnly adds AuthorizedSellerOnly ItemFilter If set to true, returns only items listed by authorized sellers

func (*RequestItemFilter) WithItemFilterAvailableTo 

func (sr *RequestItemFilter) WithItemFilterAvailableTo(code string) *RequestItemFilter

WithItemFilterAvailableTo adds AvailableTo ItemFilter Limits items to those available to the specified country only. Item filter LocatedIn cannot be used together with item filter AvailableTo. Expects the two-letter ISO 3166 country code to indicate the country where the item is located. For English names that correspond to each code (e.g., KY="Cayman Islands")

func (*RequestItemFilter) WithItemFilterBestOfferOnly 

func (sr *RequestItemFilter) WithItemFilterBestOfferOnly(b bool) *RequestItemFilter

WithItemFilterBestOfferOnly adds BestOfferOnly ItemFilter If true, the search results are limited to only items that have Best Offer enabled. Default is false.

func (*RequestItemFilter) WithItemFilterCharityOnly 

func (sr *RequestItemFilter) WithItemFilterCharityOnly(b bool) *RequestItemFilter

WithItemFilterCharityOnly adds CharityOnly ItemFilter If true, the search results are limited to items for which all or part of the proceeds are given to a charity. Each item in the search results will include the ID of the given charity. Default is false.

func (*RequestItemFilter) WithItemFilterCondition 

func (sr *RequestItemFilter) WithItemFilterCondition(conditions ...ItemFilterConditionOption) *RequestItemFilter

WithItemFilterCondition adds Condition ItemFilter This item condition filter allows a user to filter items based on item condition.

func (*RequestItemFilter) WithItemFilterConditionName added in v0.2.0 

func (sr *RequestItemFilter) WithItemFilterConditionName(conditions ...ItemFilterConditionNameOption) *RequestItemFilter

WithItemFilterConditionName adds Condition ItemFilter This item condition filter allows a user to filter items based on item condition name.

func (*RequestItemFilter) WithItemFilterCurrency 

func (sr *RequestItemFilter) WithItemFilterCurrency(currency ItemFilterCurrencyIDOption) *RequestItemFilter

WithItemFilterCurrency adds Currency ItemFilter Limits results to items listed with the specified currency only.

func (*RequestItemFilter) WithItemFilterEndTimeFrom 

func (sr *RequestItemFilter) WithItemFilterEndTimeFrom(datetime string) *RequestItemFilter

WithItemFilterEndTimeFrom adds EndTimeFrom ItemFilter Limits the results to items ending on or after the specified time. Specify a time in the future.

func (*RequestItemFilter) WithItemFilterEndTimeTo 

func (sr *RequestItemFilter) WithItemFilterEndTimeTo(datetime string) *RequestItemFilter

WithItemFilterEndTimeTo adds EndTimeTo ItemFilter Limits the results to items ending on or before the specified time. Specify a time in the future.

func (*RequestItemFilter) WithItemFilterExcludeAutoPay 

func (sr *RequestItemFilter) WithItemFilterExcludeAutoPay(b bool) *RequestItemFilter

WithItemFilterExcludeAutoPay adds ExcludeAutoPay ItemFilter If true, excludes all items requiring immediate payment. Default is false.

func (*RequestItemFilter) WithItemFilterExcludeCategory 

func (sr *RequestItemFilter) WithItemFilterExcludeCategory(categories ...string) *RequestItemFilter

WithItemFilterExcludeCategory adds ExcludeCategory ItemFilter Specify one or more category IDs. Search results will not include items from the specified categories or their child categories. Valid category IDs. 

26th and next categories will be skipped

func (*RequestItemFilter) WithItemFilterExcludeSeller 

func (sr *RequestItemFilter) WithItemFilterExcludeSeller(sellers ...string) *RequestItemFilter

WithItemFilterExcludeSeller adds ExcludeSeller ItemFilter Specify one or more seller names. Search results will not include items from the specified sellers. The ExcludeSeller item filter cannot be used together with either the Seller or TopRatedSellerOnly item filters. 

101th and next sellers will be skipped

func (*RequestItemFilter) WithItemFilterExpeditedShippingType 

func (sr *RequestItemFilter) WithItemFilterExpeditedShippingType(shipping ItemFilterExpeditedShippingTypeOption) *RequestItemFilter

WithItemFilterExpeditedShippingType adds ExpeditedShippingType ItemFilter Specifies the type of expedited shipping. You can specify either Expedited or OneDayShipping. Only items that can be shipped by the specified type are returned. ExpeditedShippingType is used together with the MaxHandlingTime and ReturnsAcceptedOnly filters to filter items for certain kinds of gifting events such as birthdays or holidays where the items must be delivered by a certain date.

func (*RequestItemFilter) WithItemFilterFeaturedOnly 

func (sr *RequestItemFilter) WithItemFilterFeaturedOnly(b bool) *RequestItemFilter

WithItemFilterFeaturedOnly adds FeaturedOnly ItemFilter If true, the search results are limited to featured item listings only. Default is false.

func (*RequestItemFilter) WithItemFilterFeedbackScoreMax 

func (sr *RequestItemFilter) WithItemFilterFeedbackScoreMax(score int) *RequestItemFilter

WithItemFilterFeedbackScoreMax adds FeedbackScoreMax ItemFilter Specifies the maximum feedback score of a seller whose items can be included in the response. If FeedbackScoreMin is also specified, the FeedbackScoreMax value must be greater than or equal to the FeedbackScoreMin value. 

Values below 0 are ignored.

func (*RequestItemFilter) WithItemFilterFeedbackScoreMin 

func (sr *RequestItemFilter) WithItemFilterFeedbackScoreMin(score int) *RequestItemFilter

WithItemFilterFeedbackScoreMin adds FeedbackScoreMin ItemFilter Specifies the mininum feedback score of a seller whose items can be included in the response. If FeedbackScoreMax is also specified, the FeedbackScoreMax value must be greater than or equal to the FeedbackScoreMin value. 

Values below are 0 ignored.

func (*RequestItemFilter) WithItemFilterFreeShippingOnly 

func (sr *RequestItemFilter) WithItemFilterFreeShippingOnly(b bool) *RequestItemFilter

WithItemFilterFreeShippingOnly adds FreeShippingOnly ItemFilter If true, the search results are limited to only items with free shipping to the site specified in the req (see Global ID Values). Default is false.

func (*RequestItemFilter) WithItemFilterGetItFastOnly 

func (sr *RequestItemFilter) WithItemFilterGetItFastOnly(b bool) *RequestItemFilter

WithItemFilterGetItFastOnly adds GetItFastOnly ItemFilter If true, the search results are limited to only Get It Fast listings. Default is false.

func (*RequestItemFilter) WithItemFilterHideDuplicateItems 

func (sr *RequestItemFilter) WithItemFilterHideDuplicateItems(b bool) *RequestItemFilter

WithItemFilterHideDuplicateItems adds HideDuplicateItems ItemFilter If true, and there are duplicate items for an item in the search results, the subsequent duplicates will not appear in the results. Default is false.

func (*RequestItemFilter) WithItemFilterListedIn 

func (sr *RequestItemFilter) WithItemFilterListedIn(globalID GlobalID) *RequestItemFilter

WithItemFilterListedIn adds ListedIn ItemFilter The site on which the items were originally listed. This can be useful for buyers who wish to see only items on their domestic site either for delivery cost reasons or time reasons, such as for gifting occasions like birthdays or holidays.

func (*RequestItemFilter) WithItemFilterListingType 

func (sr *RequestItemFilter) WithItemFilterListingType(listingTypes ...ItemFilterListingTypeOption) *RequestItemFilter

WithItemFilterListingType adds ListingType ItemFilter Filters items based listing type information. Default behavior is to return all matching items, except Store Inventory format listings.

func (*RequestItemFilter) WithItemFilterLocalPickupOnly 

func (sr *RequestItemFilter) WithItemFilterLocalPickupOnly(b bool) *RequestItemFilter

WithItemFilterLocalPickupOnly adds LocalPickupOnly ItemFilter 

If true, the search results are limited to only items which have local pickup available. Default is false.

func (*RequestItemFilter) WithItemFilterLocalSearchOnly 

func (sr *RequestItemFilter) WithItemFilterLocalSearchOnly(b bool) *RequestItemFilter

WithItemFilterLocalSearchOnly adds LocalSearchOnly ItemFilter If true, the search results are limited to only matching items with the Local Inventory Listing Options (LILO). Must be used together with the MaxDistance item filter, and the req must also specify buyerPostalCode. Currently, this is only available for the Motors site (global ID EBAY- MOTOR).

func (*RequestItemFilter) WithItemFilterLocatedIn 

func (sr *RequestItemFilter) WithItemFilterLocatedIn(codes ...string) *RequestItemFilter

WithItemFilterLocatedIn adds LocatedIn ItemFilter Limits the result set to just those items located in the specified country. Item filter AvailableTo cannot be used together with item filter LocatedIn.

Expects the two-letter ISO 3166 country code to indicate the country where the item is located. For English names that correspond to each code (e.g., KY="Cayman Islands")

func (*RequestItemFilter) WithItemFilterLotsOnly 

func (sr *RequestItemFilter) WithItemFilterLotsOnly(b bool) *RequestItemFilter

WithItemFilterLotsOnly adds LotsOnly ItemFilter If true, the search results are limited to only matching listings for which the lot size is 2 or more. Default is false.

func (*RequestItemFilter) WithItemFilterMaxBids 

func (sr *RequestItemFilter) WithItemFilterMaxBids(score int) *RequestItemFilter

WithItemFilterMaxBids adds MaxBids ItemFilter Limits the results to items with bid counts less than or equal to the specified value. If MinBids is also specified, the MaxBids value must be greater than or equal to the MinBids value. 

Values below 0 are ignored.

func (*RequestItemFilter) WithItemFilterMaxDistance 

func (sr *RequestItemFilter) WithItemFilterMaxDistance(score int) *RequestItemFilter

WithItemFilterMaxDistance adds MaxDistance ItemFilter Specifies the maximum distance from the specified postal code (buyerPostalCode) to search for items. 

The req must also specify buyerPostalCode.
Values below 5 are ignored.

func (*RequestItemFilter) WithItemFilterMaxHandlingTime 

func (sr *RequestItemFilter) WithItemFilterMaxHandlingTime(score int) *RequestItemFilter

WithItemFilterMaxHandlingTime adds MaxHandlingTime ItemFilter Specifies the maximum number of handling days the seller requires to ship the item. Only items with a handling time less than or equal to this number will be returned. (The handling time is the amount of time, in days, required by the seller to get the item ready to ship and handed off to the actual carrier who does the delivery. It does not include the time required by the carrier to deliver the item. 

Values below 1 are ignored.

func (*RequestItemFilter) WithItemFilterMaxPrice 

func (sr *RequestItemFilter) WithItemFilterMaxPrice(price float64) *RequestItemFilter

WithItemFilterMaxPrice adds MaxPrice ItemFilter Specifies the maximum current price an item can have to be included in the response. If using with MinPrice to specify a price range, the MaxPrice value must be greater than or equal to MinPrice. 

Values below 0 are ignored.

func (*RequestItemFilter) WithItemFilterMaxPriceWithCurrency 

func (sr *RequestItemFilter) WithItemFilterMaxPriceWithCurrency(price float64, currency ItemFilterCurrencyIDOption) *RequestItemFilter

WithItemFilterMaxPriceWithCurrency adds MaxPrice ItemFilter Specifies the maximum current price an item can have to be included in the response. If using with MinPrice to specify a price range, the MaxPrice value must be greater than or equal to MinPrice. 

Values below 0 are ignored.

func (*RequestItemFilter) WithItemFilterMaxQuantity 

func (sr *RequestItemFilter) WithItemFilterMaxQuantity(score int) *RequestItemFilter

WithItemFilterMaxQuantity adds MaxQuantity ItemFilter Limits the results to listings with a quantity less than or equal to the specified value. If MinQuantity is also specified, the MaxQuantity value must be greater than or equal to the MinQuantity value. 

Values below 1 are ignored.

func (*RequestItemFilter) WithItemFilterMinBids 

func (sr *RequestItemFilter) WithItemFilterMinBids(score int) *RequestItemFilter

WithItemFilterMinBids adds MinBids ItemFilter Limits the results to items with bid counts greater than or equal to the specified value. If MaxBids is also specified, the MaxBids value must be greater than or equal to the MinBids value. 

Values below 0 are ignored.

func (*RequestItemFilter) WithItemFilterMinPrice 

func (sr *RequestItemFilter) WithItemFilterMinPrice(price float64) *RequestItemFilter

WithItemFilterMinPrice adds MinPrice ItemFilter Specifies the minimum current price an item can have to be included in the response. If using with MaxPrice to specify a price range, the MaxPrice value must be greater than or equal to MinPrice. 

Values below 0 are ignored.

func (*RequestItemFilter) WithItemFilterMinPriceWithCurrency 

func (sr *RequestItemFilter) WithItemFilterMinPriceWithCurrency(price float64, currency ItemFilterCurrencyIDOption) *RequestItemFilter

WithItemFilterMinPriceWithCurrency adds MinPrice ItemFilter Specifies the minimum current price an item can have to be included in the response. If using with MaxPrice to specify a price range, the MaxPrice value must be greater than or equal to MinPrice. 

Values below 0 are ignored.

func (*RequestItemFilter) WithItemFilterMinQuantity 

func (sr *RequestItemFilter) WithItemFilterMinQuantity(score int) *RequestItemFilter

WithItemFilterMinQuantity adds MinQuantity ItemFilter Limits the results to listings with a quantity greater than or equal to the specified value. If MaxQuantity is also specified, the MaxQuantity value must be greater than or equal to the MinQuantity value. 

Values below 1 are ignored.

func (*RequestItemFilter) WithItemFilterModTimeFrom 

func (sr *RequestItemFilter) WithItemFilterModTimeFrom(datetime string) *RequestItemFilter

WithItemFilterModTimeFrom adds ModTimeFrom ItemFilter Limits the results to active items whose status has changed since the specified time. Specify a time in the past. Time must be in GMT.

func (*RequestItemFilter) WithItemFilterOutletSellerOnly 

func (sr *RequestItemFilter) WithItemFilterOutletSellerOnly(b bool) *RequestItemFilter

WithItemFilterOutletSellerOnly adds OutletSellerOnly ItemFilter If set to true, returns only items listed by outlet sellers.

func (*RequestItemFilter) WithItemFilterPaymentMethod 

func (sr *RequestItemFilter) WithItemFilterPaymentMethod(payment ItemFilterPaymentMethodOption) *RequestItemFilter

WithItemFilterPaymentMethod adds PaymentMethod ItemFilter Limits results to items that accept the specified payment method.

func (*RequestItemFilter) WithItemFilterReturnsAcceptedOnly 

func (sr *RequestItemFilter) WithItemFilterReturnsAcceptedOnly(b bool) *RequestItemFilter

WithItemFilterReturnsAcceptedOnly adds ReturnsAcceptedOnly ItemFilter If set to true, returns only items where the seller accepts returns.

func (*RequestItemFilter) WithItemFilterSeller 

func (sr *RequestItemFilter) WithItemFilterSeller(sellers ...string) *RequestItemFilter

WithItemFilterSeller adds Seller ItemFilter The Seller item filter cannot be used together with either the ExcludeSeller or TopRatedSellerOnly item filters. Multiple values are allowed. Up to 100 sellers can be specified. 

101th and next sellers will be skipped

func (*RequestItemFilter) WithItemFilterSellerBusinessType 

func (sr *RequestItemFilter) WithItemFilterSellerBusinessType(businessType ItemFilterSellerBusinessTypeOption) *RequestItemFilter

WithItemFilterSellerBusinessType adds SellerBusinessType ItemFilter Restricts the items to those that are from sellers whose business type is the specified value. Only one value can be specified.

func (*RequestItemFilter) WithItemFilterSoldItemsOnly 

func (sr *RequestItemFilter) WithItemFilterSoldItemsOnly(b bool) *RequestItemFilter

WithItemFilterSoldItemsOnly adds SoldItemsOnly ItemFilter Reserved for future use. If true, excludes all completed items which are not ended by being sold.

func (*RequestItemFilter) WithItemFilterStartTimeFrom 

func (sr *RequestItemFilter) WithItemFilterStartTimeFrom(datetime string) *RequestItemFilter

WithItemFilterStartTimeFrom adds StartTimeFrom ItemFilter Limits the results to items started on or after the specified time. Specify a time in the future.

func (*RequestItemFilter) WithItemFilterStartTimeTo 

func (sr *RequestItemFilter) WithItemFilterStartTimeTo(datetime string) *RequestItemFilter

WithItemFilterStartTimeTo adds StartTimeTo ItemFilter Limits the results to items started on or before the specified time. Specify a time in the future.

func (*RequestItemFilter) WithItemFilterTopRatedSellerOnly 

func (sr *RequestItemFilter) WithItemFilterTopRatedSellerOnly(b bool) *RequestItemFilter

WithItemFilterTopRatedSellerOnly adds TopRatedSellerOnly ItemFilter The TopRatedSellerOnly item filter cannot be used together with either the Seller or ExcludeSeller item filters. The TopRatedSellerOnly item filter is supported for the following sites only: US (EBAY-US), Motors (EBAY-MOTOR), UK (EBAY-GB), IE (EBAY-IE), DE (EBAY-DE), AT (EBAY-AT), and CH (EBAY-CH).

func (*RequestItemFilter) WithItemFilterValueBoxInventory 

func (sr *RequestItemFilter) WithItemFilterValueBoxInventory(b bool) *RequestItemFilter

WithItemFilterValueBoxInventory adds ValueBoxInventory ItemFilter 

Coming Soon!

Coming Soon: This filter can be used in conjunction with the sortOrder PricePlusShippingLowest to return competitively priced items from eBay top-rated sellers that have a BuyItNow price, with the lowest priced item at the top of the list. This filter returns items from categories that are catalog-enabled; items from non catalog-enabled categories are not returned. Sellers can use this item filter to determine competitive pricing; buying applications can use it to obtain competitive items from top rated sellers that are likely to sell quickly.

If set to 1, the item filter constraints are applied and the items are returned accordingly. If set to 0 (zero) the item filter is not applied. Defaults to 0.

func (*RequestItemFilter) WithItemFilterWorldOfGoodOnly 

func (sr *RequestItemFilter) WithItemFilterWorldOfGoodOnly(b bool) *RequestItemFilter

WithItemFilterWorldOfGoodOnly adds WorldOfGoodOnly ItemFilter If true, the search results are limited to only items listed in the World of Good marketplace. Defaults to false.

type RequestKeywords 

type RequestKeywords struct {
	Keywords string `json:"keywords,omitempty" xml:"keywords,omitempty"`
}

RequestKeywords represents filter by keywords in ebay Finding requests

func (*RequestKeywords) WithKeywords 

func (sr *RequestKeywords) WithKeywords(key string) *RequestKeywords

WithKeywords adds keywords for searching Max length: 350. The maximum length for a single word is 98. Min length: 2. Key longer than 350 symbols will be trimmed. Key shorter 2 (0 < n < 2) symbols won't change Keywords field. Empty string removes Keywords field.

type RequestOutputSelector 

type RequestOutputSelector struct {
	OutputSelector []string `json:"outputSelector,omitempty" xml:"outputSelector,omitempty"`
}

RequestOutputSelector represents outputSelector part of ebay Finding requests

func (*RequestOutputSelector) WithOutputSelectors 

func (sr *RequestOutputSelector) WithOutputSelectors(osps ...OutputSelectorParameter) *RequestOutputSelector

WithOutputSelectors adds OutputSelectors

type RequestProduct 

type RequestProduct struct {
	ProductID Product `json:"productId,omitempty" xml:"productId,omitempty"`
}

RequestProduct represents filter by products in ebay Finding requests

func (*RequestProduct) WithProductType 

func (sr *RequestProduct) WithProductType(productType ProductTypeOption, id string) *RequestProduct

WithProductType adds productId to req

type RequestStandard 

type RequestStandard struct {
	PaginationInput ServicePaginationInput `json:"paginationInput,omitempty" xml:"paginationInput,omitempty"`
	SortOrder       string                 `json:"sortOrder,omitempty" xml:"sortOrder,omitempty"`
	Affiliate       *ServiceAffiliate      `json:"affiliate,omitempty" xml:"affiliate,omitempty"`
	BuyerPostalCode string                 `json:"buyerPostalCode,omitempty" xml:"buyerPostalCode,omitempty"`

	RequestBasic
}

RequestStandard represents basic part of ebay Finding request

func (*RequestStandard) WithAffiliate added in v0.2.0 

func (sr *RequestStandard) WithAffiliate(networkID, trackingID, customID string) *RequestStandard

WithAffiliate adds ServiceAffiliate

func (*RequestStandard) WithBuyerPostalCode added in v0.2.0 

func (sr *RequestStandard) WithBuyerPostalCode(code string) *RequestStandard

WithBuyerPostalCode adds BuyerPostalCode to requests

func (*RequestStandard) WithPageLimit 

func (sr *RequestStandard) WithPageLimit(limit int) *RequestStandard

WithPageLimit sets page limit to list of items 

Min: 1. Max: 100. Default: 100.

func (*RequestStandard) WithPageNumber 

func (sr *RequestStandard) WithPageNumber(page int) *RequestStandard

WithPageNumber sets page to get 

Min: 1. Max: 100. Default: 100.

func (*RequestStandard) WithSortOrder 

func (sr *RequestStandard) WithSortOrder(order SortOrderParameter) *RequestStandard

WithSortOrder sorts the returned items according to a single specified sort order. Default: BestMatch.

type ResponseAspectHistogramContainer 

type ResponseAspectHistogramContainer struct {
	AspectHistogramContainer AspectHistogramContainer `xml:"aspectHistogramContainer"`
}

type ResponseCategoryHistogramContainer 

type ResponseCategoryHistogramContainer struct {
	CategoryHistogramContainer CategoryHistogramContainer `json:"categoryHistogramContainer" xml:"categoryHistogramContainer"`
}

type ResponseConditionHistogramContainer 

type ResponseConditionHistogramContainer struct {
	ConditionHistogramContainer ConditionHistogramContainer `json:"conditionHistogramContainer" xml:"conditionHistogramContainer"`
}

type ResponsePaginationOutput 

type ResponsePaginationOutput struct {
	PaginationOutput PaginationOutput `xml:"paginationOutput"`
}

type ResponseSearchResult 

type ResponseSearchResult struct {
	SearchResult SearchResult `xml:"searchResult"`
}

type SearchResult 

type SearchResult struct {
	Count int    `xml:"count,attr"`
	Items []Item `xml:"item"`
}

SearchResult is a container for the item listings that matched the search criteria. The data for each item is returned in individual containers, if any matches were found.

type SellerInfo 

type SellerInfo struct {
	FeedbackRatingStar      string  `xml:"feedbackRatingStar"`
	FeedbackScore           int64   `xml:"feedbackScore"`
	PositiveFeedbackPercent float64 `xml:"positiveFeedbackPercent"`
	SellerUserName          string  `xml:"sellerUserName"`
	TopRatedSeller          bool    `xml:"topRatedSeller"`
}

type SellingStatus 

type SellingStatus struct {
	BidCount              int    `xml:"bidCount"`
	ConvertedCurrentPrice Price  `xml:"convertedCurrentPrice"`
	CurrentPrice          Price  `xml:"currentPrice"`
	SellingState          string `xml:"sellingState"`
	TimeLeft              string `xml:"timeLeft"`
}

type Service 

type Service struct {
	// contains filtered or unexported fields
}

Service represents Ebay Finding API service

func NewService 

func NewService(securityAppName string) *Service

NewService creates new Ebay Finding API service API version according to EbayFindingAPIVersion (1.13.0) Default endpoint: EbayEndpointProduction (https://svcs.ebay.com/services/search/FindingService/v1) Default GlobalID: GlobalIDEbayUS (EBAY-US) Default Page Limit: DefaultItemsPerPage (100) Default timeout for requests: 10 seconds

func (*Service) NewAdvancedRequest 

func (s *Service) NewAdvancedRequest() *AdvancedRequest

NewAdvancedRequest creates new AdvancedRequest

func (*Service) NewByCategoryRequest 

func (s *Service) NewByCategoryRequest() *ByCategoryRequest

NewByCategoryRequest creates new ByCategoryRequest

func (*Service) NewByKeywordsRequest 

func (s *Service) NewByKeywordsRequest() *ByKeywordsRequest

NewByKeywordsRequest creates new ByKeywordsRequest

func (*Service) NewByProductRequest 

func (s *Service) NewByProductRequest() *ByProductRequest

NewByProductRequest creates new ByProductRequest

func (*Service) NewGetHistogramsRequest 

func (s *Service) NewGetHistogramsRequest() *GetHistogramsRequest

NewGetHistogramsRequest creates new GetHistogramsRequest

func (*Service) NewGetKeywordsRecommendationRequest 

func (s *Service) NewGetKeywordsRecommendationRequest() *GetKeywordsRecommendationRequest

NewGetKeywordsRecommendationRequest creates new GetKeywordsRecommendationRequest

func (*Service) NewGetVersionRequest 

func (s *Service) NewGetVersionRequest() *GetVersionRequest

NewGetVersionRequest creates new GetVersionRequest

func (*Service) NewInEbayStoresRequest 

func (s *Service) NewInEbayStoresRequest() *InEbayStoresRequest

NewInEbayStoresRequest creates new InEbayStoresRequest

func (*Service) WithEndpoint 

func (s *Service) WithEndpoint(endpoint string) *Service

WithEndpoint changes endpoint for service You can add your own endpoint (for tests purposes)

func (*Service) WithGlobalID 

func (s *Service) WithGlobalID(globalID GlobalID) *Service

WithGlobalID changes site for search

func (*Service) WithPageLimit 

func (s *Service) WithPageLimit(limit int) *Service

WithPageLimit changes limit of items for any child req

func (*Service) WithTimeout 

func (s *Service) WithTimeout(timeout time.Duration) *Service

WithTimeout changes default timeout for search requests

type ServiceAffiliate added in v0.2.0 

type ServiceAffiliate struct {
	NetworkID  string `json:"networkId,omitempty" xml:"networkId,omitempty"`
	TrackingID string `json:"trackingId,omitempty" xml:"trackingId,omitempty"`
	CustomID   string `json:"customId,omitempty" xml:"customId,omitempty"`
}

ServiceAffiliate represents Affiliate Program

type ServiceAspectFilter 

type ServiceAspectFilter struct {
	AspectName      string   `json:"aspectName" xml:"aspectName"`
	AspectValueName []string `json:"aspectValueName" xml:"aspectValueName"`
}

ServiceAspectFilter represents AspectFilter

type ServiceItemFilter 

type ServiceItemFilter struct {
	Name       string   `json:"name" xml:"name"`
	Value      []string `json:"value" xml:"value"`
	ParamName  string   `json:"paramName,omitempty" xml:"paramName,omitempty"`
	ParamValue string   `json:"paramValue,omitempty" xml:"paramValue,omitempty"`
}

ServiceItemFilter represents ItemFilter unit

type ServicePaginationInput 

type ServicePaginationInput struct {
	EntriesPerPage int `json:"entriesPerPage,omitempty" xml:"entriesPerPage,omitempty"`
	PageNumber     int `json:"pageNumber,omitempty" xml:"pageNumber,omitempty"`
}

ServicePaginationInput represents PaginationInput

type ShippingInfo 

type ShippingInfo struct {
	ExpeditedShipping       bool     `xml:"expeditedShipping"`
	OneDayShippingAvailable bool     `xml:"oneDayShippingAvailable"`
	HandlingTime            int      `xml:"handlingTime"`
	ShippingServiceCost     Price    `xml:"shippingServiceCost"`
	ShippingType            string   `xml:"shippingType"`
	ShipToLocations         []string `xml:"shipToLocations"`
}

type SortOrderParameter 

type SortOrderParameter string
const (
	SortOrderBestMatch                SortOrderParameter = "BestMatch"
	SortOrderBidCountFewest           SortOrderParameter = "BidCountFewest"
	SortOrderBidCountMost             SortOrderParameter = "BidCountMost"
	SortOrderCountryAscending         SortOrderParameter = "CountryAscending"
	SortOrderCountryDescending        SortOrderParameter = "CountryDescending"
	SortOrderCurrentPriceHighest      SortOrderParameter = "CurrentPriceHighest"
	SortOrderDistanceNearest          SortOrderParameter = "DistanceNearest"
	SortOrderEndTimeSoonest           SortOrderParameter = "EndTimeSoonest"
	SortOrderPricePlusShippingHighest SortOrderParameter = "PricePlusShippingHighest"
	SortOrderPricePlusShippingLowest  SortOrderParameter = "PricePlusShippingLowest"
	SortOrderStartTimeNewest          SortOrderParameter = "StartTimeNewest"
	SortOrderWatchCountDecreaseSort   SortOrderParameter = "WatchCountDecreaseSort"
)

type StoreInfo 

type StoreInfo struct {
	StoreName string `xml:"storeName"`
	StoreURL  string `xml:"storeURL"`
}

type UnitPriceInfo 

type UnitPriceInfo struct {
	Quantity int64  `xml:"quantity"`
	Type     string `xml:"type"`
}

type ValueHistogram 

type ValueHistogram struct {
	ValueName string `xml:"valueName,attr"`
	// Count is the number of items that share the characteristic the respective aspect value.
	Count int64 `xml:"count"`
}

ValueHistogram is a container that returns the name of the respective aspect value and the histogram 

(the number of available items) that share that item characteristic.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.