Subversion Repositories SmartDukaan

namespace java in.shop2020.model.v1.catalog
namespace py shop2020.thriftpy.model.v1.catalog

include "GenericService.thrift"
include "DtrService.thrift"

/**
        Objects
*/

/**
Caution :- Never ever change the numbers in it. Please confirm from @Chandranshu or @Rajveer before any changes in enum and other entries in file.
**/
enum status {
        PHASED_OUT = 0,         //Item is no longer selling
        DELETED = 1,            //Item has been deliberately deleted 
        PAUSED = 2,                     //Item's sale has been paused manually.
        ACTIVE = 3,                     //Item is available for sale as of now
        IN_PROCESS = 4,         //Item has been added, but content is not available for the same
        CONTENT_COMPLETE = 5,  //The content for this item has been completed. We can start selling the item now.
        PAUSED_BY_RISK = 6,    //Item's sale has been automatically paused since it was marked as risky
        COMING_SOON= 7,         //Item is now in Coming Soon Page and will move to ACTIVE gradually as it achieves the Start date.
        PARTIALLY_ACTIVE=8
}

enum ItemType {
    SERIALIZED = 1,
    NON_SERIALIZED = 2
}

enum PremiumType {
    PERCENT = 1,
    ABSOLUTE = 2
}

enum BannerType{
        WEBSITE  = 1,
        SIDE_BANNER = 2,
        MOBILE_SITE = 3
}

enum InsurerType {
        DEVICE = 1,
        DATA = 2
}

enum CompetitionCategory {
        CANT_COMPETE = 1,
        BUY_BOX = 2,
        COMPETITIVE = 3,
        COMPETITIVE_NO_INVENTORY = 4,
        EXCEPTION = 5,
        NEGATIVE_MARGIN = 6,
        CHEAP_BUT_NOT_PREF = 7,
        PREF_BUT_NOT_CHEAP = 8,
        AMONG_CHEAPEST_CAN_COMPETE = 9,
        ALMOST_COMPETE = 10
}

enum CompetitionBasis {
        SP = 1, 
        TP = 2
}

enum SalesPotential {
        HIGH = 1,
        MEDIUM = 2,
        LOW = 3 
}

enum Decision {
        AUTO_DECREMENT_SUCCESS = 1,
        AUTO_INCREMENT_SUCCESS = 2,
        AUTO_DECREMENT_FAILED = 3,
        AUTO_INCREMENT_FAILED = 4
}

enum RunType {
        FULL = 1,
        FAVOURITE = 2
}

enum AmazonPromotionType {
        LONGTERM = 1,
        SHORTTERM = 2
}

struct Item{
        1:i64 id,
        2:string productGroup
        3:string brand,
        4:string modelNumber,
        5:string modelName,
        6:string color,
        7:i64 category,
        8:string comments,
        9:i64 catalogItemId,
        10:i64 featureId,
        11:string featureDescription,
        13:optional double mrp, //maxmimum retail price
        14:optional double sellingPrice, //Selling price
        15:optional double weight,
        16:i64 addedOn,
        17:optional i64 startDate,
        18:optional i64 retireDate,
        19:status itemStatus,
        20:string status_description,
        21:map<string,string> otherInfo,
        22:string bestDealText,
        23:optional double bestDealValue,
        24:bool defaultForEntity,
        25:i64 updatedOn,
        26:optional i64 bestSellingRank,
        27:bool risky,
        28:optional i32 expectedDelay,
        29:optional bool isWarehousePreferenceSticky,
        30:i32 warrantyPeriod,
        31:optional i64 preferredVendor,
        32:ItemType type,
        33:optional i64 comingSoonStartDate,
        34:optional i64 expectedArrivalDate,
        35:bool hasItemNo,
        36:bool activeOnStore,
        38:bool showSellingPrice,
        39:string bestDealsDetailsText,
        40:string bestDealsDetailsLink,
        41:i64 preferredInsurer,
        42:string asin,
        43:i64 defaultInventory,
        44:i64 holdInventory,
        45:bool holdOverride,
        46:i64 packQuantity,
        47:i64 quantityStep,
        48:i64 minimumBuyQuantity,
        49:i64 maximumBuyQuantity 
        50:optional double dealPrice,
        51:string hsnCode
}

struct StateGstRate{
        1:i64 itemId,
        2:i64 stateId,
        3:double igstRate,
        4:double cgstRate,
        5:double sgstRate
}

struct Insurer{
        1:i64 id,
        2:string name,
        3:string address,
        4:i64 declaredAmount,
        5:i64 creditedAmount,
        6:InsurerType insurerType
}

struct ItemInsurerMapping{
        1:i64 itemId,
        2:i64 insurer,
        3:PremiumType premiumType,
        4:double premiumValue,
        5:InsurerType insurerType
}

struct Category{
        1:i64 id,
        2:string label,
        3:string description,
        4:i64 parent_category_id,
        /**
        * This field should not be used.
        */
        5:list<i64> children_category_ids
        6:string display_name
}

struct ItemShippingInfo{
        1:bool isActive,
        2:optional bool isRisky,
        3:optional i64 quantity
}

struct Source{
        1:i64 id,
        2:string name,
        3:string identifier
}

struct SourceItemPricing{
        1:i64 sourceId,
        2:i64 itemId,
        3:double mrp,
        4:double sellingPrice
}

struct OutbuoundAffiliate {
        1:i64 id,
        2:string name
}

struct ExclusiveAffiliateItemInfo {
        1:i64 itemId,
        2:i64 affiliateId,
        3:string affiliateName,
        4:string offerText,
        5:string offerImageUrl,
        6:string mOfferText,
        7:string mOfferImageUrl,
        8:string affiliateSku,
        9:string affiliateUrl,
        10:bool active
}

struct ProductNotificationRequest       {
        1:Item item,
        2:string email,
        3:i64 addedOn
}

struct ProductNotificationRequestCount  {
        1:Item item,
        2:i64 count
}

struct VoucherItemMapping{
        1:i64 voucherType,
        2:i64 itemId,
        3:i64 amount
}

exception CatalogServiceException{
        1:i64 id,
        2:string message
}

struct EntityTag {
    1:i64 entityId,
    2:string tag
}

struct Banner {
    1:string bannerName,
    2:string imageName,
    3:string link,
    4:bool hasMap,
    5:i64 priority,
    6:BannerType bannerType,
    7:bool target
}

struct BannerUriMapping{
        1:string bannerName,
        2:string uri,
        3:bool isActive,
        4:bool target
}

struct BannerMap {
    1:string bannerName,
    2:string mapLink,
    3:string coordinates
}

struct BannerCongregate{
        1:Banner banner,
        2:list<BannerMap> bannerMaps,
        3:list<BannerUriMapping> bannerUriMappings,
        4:Banner antecedent 
}

struct Campaign {
        1:i64 id,
        2:string campaignName,
        3:string imageName
}

struct FreebieItem {
        1:i64 itemId,
        2:i64 freebieItemId
}

struct BrandInfo {
        1:string name,
        2:string serviceCenterLocatorUrl
}

struct StorePricing {
    1:i64 itemId,
        2:double recommendedPrice,
        3:double minPrice,
        4:double maxPrice,
        5:double minAdvancePrice,
        6:double absoluteMinPrice,
        7:i64 freebieItemId,
        8:string bestDealText
}

struct Amazonlisted{
        1:i64 itemid,
    2:string asin,
    3:string name,
    4:string brand,
    5:string model,
    6:string manufacturer_name,
    7:string part_number,
    8:string ean,
    9:string upc 
    10:double fbaPrice,
    11:double sellingPrice,
    12:bool isFba,
    13:bool isNonFba,
    14:bool isInventoryOverride,
    15:string color,
    16:string category,
    17:i64 handlingTime,
    18:bool isCustomTime,
    19:i64 category_code,
    20:i64 mfnPriceLastUpdatedOn,
    21:i64 fbaPriceLastUpdatedOn,
    22:i64 mfnPriceLastUpdatedOnSc,
    23:i64 fbaPriceLastUpdatedOnSc
    24:bool suppressMfnPriceUpdate,
    25:bool suppressFbaPriceUpdate,
    26:string taxCode,
    27:string fbbtaxCode,
    28:double fbbPrice,
    29:i64 fbbPriceLastUpdatedOnSc,
    30:i64 fbbPriceLastUpdatedOn,
    31:bool isFbb,
    32:bool suppressFbbPriceUpdate,
    33:double fbaPromoPrice,
    34:double fbbPromoPrice,
    35:bool overrrideWanlc,
    36:double exceptionalWanlc,
    37:bool autoIncrement,
    38:bool autoDecrement,
    39:bool autoFavourite,
    40:bool manualFavourite,
    41:double otherCost,
    42:i64 fbaPromoStartDate,
    43:i64 fbaPromoEndDate,
    44:i64 fbbPromoStartDate,
    45:i64 fbbPromoEndDate,
    46:bool isFbaPromotionActive,
    47:bool isFbbPromotionActive,
    48:double maxFbaSalePrice,
    49:double maxFbbSalePrice,
    50:bool isFbg,
    51:double fbgPrice,
    52:string fbgtaxCode,
    53:i64 fbgPriceLastUpdatedOnSc,
    54:i64 fbgPriceLastUpdatedOn,
    55:bool suppressFbgPriceUpdate,
    56:double fbgPromoPrice,
    57:i64 fbgPromoStartDate,
    58:i64 fbgPromoEndDate,
    59:double maxFbgSalePrice,
    60:bool isFbgPromotionActive,
    61:bool isFbd,
    62:double fbdPrice,
    63:string fbdtaxCode,
    64:i64 fbdPriceLastUpdatedOnSc,
    65:i64 fbdPriceLastUpdatedOn,
    66:bool suppressFbdPriceUpdate,
    67:double fbdPromoPrice,
    68:i64 fbdPromoStartDate,
    69:i64 fbdPromoEndDate,
    70:double maxFbdSalePrice,
    71:bool isFbdPromotionActive,
    72:double packagingHeight,  //Inches
    73:double packagingLength,  //Inches
    74:double packagingWidth, //Inches
    75:double packagingWeight   //Pounds 
}
    
struct PageViewEvents{
    1:i64 catalogId,
    2:string url,
    3:double sellingPrice,
    4:bool comingSoon,
    5:string ip,
    6:string sessionId,
    7:i64 eventDate
}

struct CartEvents{
    1:i64 catalogId,
    2:i64 itemId,
    3:double sellingPrice,
    4:string ip,
    5:string sessionId,
    6:bool inStock,
    7:bool comingSoon,
    8:i64 eventDate
}
    
struct EbayItem{
        1:string ebayListingId,
        2:i64 itemId,
        3:string listingName,
        4:i64 listingPrice,
        5:i64 listingExpiryDate,
        6:double subsidy,
        7:i64 defaultWarehouseId
}

/*
        Return Provision, vat, commission, service tax are in percentage
*/

struct MarketplaceItems{
        1:i64 itemId,
        2:i64 source,
        3:double emiFee,
        4:double courierCost,
        5:double closingFee,
        6:double returnProvision,
        7:double commission,
        8:double vat,
        9:double packagingCost,
        10:double otherCost,
        11:double serviceTax,
        12:bool autoIncrement,
        13:bool autoDecrement,
        14:bool manualFavourite,
        15:bool autoFavourite,
        16:double currentSp,
        17:double currentTp,
        18:double minimumPossibleSp,
        19:double minimumPossibleTp,
        20:i64 lastCheckedTimestamp,
        21:double maximumSellingPrice,
        22:double pgFee,
        23:double courierCostMarketplace
}

struct SnapdealItem{
        1:i64 item_id,
        2:i64 warehouseId,
        3:double exceptionPrice,
        4:bool isListedOnSnapdeal,
        5:double transferPrice,
    6:double sellingPrice,
    7:double courierCost,
    8:double commission,
    9:double serviceTax,
    10:bool suppressPriceFeed,
    11:bool suppressInventoryFeed,
    12:double maxNlc,
    13:string skuAtSnapdeal,
    14:string supc,
    15:string shippingTime,
    16:string updatedBy,
    17:MarketplaceItems marketplaceItems,
    18:double courierCostMarketplace,
    19:Item item,
    20:bool isVoiListed,
    21:double voiSellingPrice,
    22:bool suppressVoiPriceFeed,
    23:i64 voiPriceLastUpdatedOn,
    24:string voiSkuAtSnapdeal,
    25:double minimumPossibleSpVoi,
        26:double minimumPossibleTpVoi,
        27:double courierCostVoi,
        28:double serviceTaxVoi,
        29:double transferPriceVoi,
        30:double commissionVoi,
        31:double courierCostMarketplaceVoi,
        32:double commissionPercentageVoi
}    

struct VoiSnapdealItemInfo {
        1:i64 item_id,
        2:string voiSkuAtSnapdeal,
        3:double sellingPriceSnapdeal,
        4:double transferPriceSnapdeal,
        5:double fixedMargin,
        6:double fixedMarginPercentage,
        7:double logisticCostSnapdeal,
        8:double woodenPackagingCost,
        9:double weightSnapdeal
}

struct SnapdealItemDetails{
        1:i64 item_id,
        2:i64 warehouseId,
        3:double exceptionPrice,
        4:bool isListedOnSnapdeal,
        5:double transferPrice,
    6:double sellingPrice,
    7:double courierCost,
    8:double commission,
    9:double serviceTax,
    10:string brand,
    11:string model_name,
    12:string model_number,
    13:string color,
    14:bool risky,
    15:status itemStatus,
    16:bool suppressPriceFeed,
    17:bool suppressInventoryFeed,
    18:double weight,
    19:double mrp,
    20:double websiteSellingPrice,
    21:double maxNlc,
    22:string skuAtSnapdeal,
    23:string supc,
    24:i64 lastUpdatedInventory,
    25:i64 lastUpdatedInventoryTimestamp,
    26:i64 shippingTime,
    27:double courierCostMarketplace,
    28:bool isVoiListed
}

struct ProductFeedSubmit{
        1:i64 catalogItemId,
        2:bool stockLinkedFeed
}    

struct MarketplaceSearchFilter{
        1:bool isListedOnMarketplace,
        2:bool isInventoryOverride,
        3:bool isPriceOverride,
        4:bool isManualFavourite,
        5:bool isAutoFavourite,
        6:bool isAutoDecrement,
        7:bool isAutoIncrement,
        8:i64 source
}

/*
        Return Provision, emiFee, commission, service tax are in percentage
*/

struct MarketplacePercentage{
        1:i64 source,
        2:double emiFee,
        3:double closingFee,
        4:double returnProvision,
        5:double commission,
        6:double serviceTax,
        7:double pgFee
}

struct MarketPlaceItemPrice{
    1:i64 item_id,
        2:i64 source,
        3:double sellingPrice,
        4:i64 lastUpdatedOn,
        5:i64 lastUpdatedOnMarketplace,
        6:bool isPriceOverride,
        7:bool isListedOnSource
    
}

struct FlipkartItem{
    1:i64 item_id,
    2:double exceptionPrice,
    3:i64 warehouseId,
    4:double commissionValue,
    5:double serviceTaxValue,
    6:double maxNlc,
    7:string skuAtFlipkart,
    8:bool isListedOnFlipkart,
    9:bool suppressPriceFeed,
    10:bool suppressInventoryFeed,
    11:string updatedBy,
    12:string flipkartSerialNumber,
    13:MarketplaceItems marketplaceItems,
    14:Item item,
    15:bool isFaListed
}

struct FlipkartItemDetails{
        1:i64 item_id,
        2:i64 warehouseId,
        3:double exceptionPrice,
        4:bool isListedOnFlipkart,
    5:double commission,
    6:double serviceTax,
    7:string brand,
    8:string model_name,
    9:string model_number,
    10:string color,
    11:bool risky,
    12:status itemStatus,
    13:bool suppressPriceFeed,
    14:bool suppressInventoryFeed,
    15:double weight,
    16:double mrp,
    17:double websiteSellingPrice,
    18:double maxNlc,
    19:string skuAtFlipkart,
    20:i64 lastUpdatedInventory,
    21:i64 lastUpdatedInventoryTimestamp,
    22:string flipkartSerialNumber,
    23:i64 category,
    24:bool isFaListed
}

struct PrivateDeal{
        1:i64 item_id,
        2:double dealPrice,
        3:i64 dealFreebieItemId,
    4:i64 startDate,
    5:i64 endDate,
    6:i64 dealTextOption,
    7:string dealText,
    8:bool isCod,
    9:i64 rank,
    10:i64 dealFreebieOption,
    11:bool isActive
}


struct GstRate {
        1:double sgstRate,
        2:double cgstRate,
        3:double igstRate,
        4:string hsnCode
}

struct StateGstRates {
        1:string stateCode,
        2:map<string, GstRate> gstRatesMap;
}

struct MarketplaceHistory{
        1:i64 item_id,
        2:i64 source,
        3:i64 timestamp,
        4:i64 lowest_possible_tp,
        5:i64 lowest_possible_sp,
        6:i64 ourInventory,
        7:i64 otherInventory,
        8:i64 secondLowestInventory,
        9:i64 ourRank,
        10:i64 ourOfferPrice,
        11:i64 ourSellingPrice,
        12:i64 ourTp,
        13:i64 ourNlc,
        14:CompetitionCategory competitiveCategory,
        15:i64 risky,
        16:i64 lowestOfferPrice,
        17:i64 lowestSellingPrice,
        18:i64 lowestTp,
        19:string lowestSellerName,
        20:i64 proposedSellingPrice,
        21:i64 proposedTp,
        22:i64 targetNlc,
        23:SalesPotential salesPotential,
        24:string secondLowestSellerName,
        25:i64 secondLowestSellingPrice,
        26:i64 secondLowestOfferPrice,
        27:i64 secondLowestTp,
        28:i64 marginIncreasedPotential,
        29:i64 margin,
        30:bool ourEnoughStock,
        31:i64 totalSeller,
        32:double averageSale,
        33:bool toGroup,
        34:Decision decision,
        35:string reason
}

struct CategoryHsnCode {
        1:i64 categoryId,
        2:string hsnCode,
        3:string description
}

struct AmazonOutOfSync{
        1:i64 item_id,
        2:bool mfn,
        3:bool fba,
        4:bool fbb
}

struct PdPriceComp{
        1:i64 item_id,
        2:double dealPrice,
        3:double saholicPrice,
        4:double sdPrice,
        5:double fkPrice,
        6:double amazonPrice,
        7:string productName,
        8:i64 lastProcessedTimestamp,
        9:double diff
}
/*
struct DealTag{
        1:i64 id,
        2:string name
}

struct ItemTag{
        1:i64 itemId,
        2:i64 tagId,
        3:i64 startDate,
        4:i64 endDate,
        5:bool status
}*/

struct CompetitorPricing {
        1:i64 item_id,
        2:bool isSnapdeal,
        3:bool isFlipkart,
        4:bool isAmazon,
        5:double lowestSnapdealPrice,
        6:double lowestFlipkartPrice,
        7:bool processed,
        8:i64 uploadId,
        9:string userEmail,
        10:double ourSnapdealPrice,
        11:double ourSnapdealOfferPrice,
        12:i64 ourSnapdealInventory,
        13:double lowestSnapdealOfferPrice,
        14:string lowestSnapdealSeller,
        15:i64 lowestSnapdealSellerInventory,
        16:double ourFlipkartPrice,
        17:i64 ourFlipkartInventory,
        18:string lowestFlipkartSeller,
        19:double ourAmazonPrice,
        20:double lowestAmazonPrice,
        21:string lowestAmazonSeller,
        22:string productName
}

struct AmazonPromotion{
        1:string sku,
        2:double standardPrice,
        3:double salePrice,
        4:i64 startDate,
        5:i64 endDate,
        6:i64 addedOn,
        7:i64 updatedOnMarketplace
        8:i64 stateId,
        9:bool promotionActive,
        10:double subsidyAmount,
        11:AmazonPromotionType promotionType
}

struct HsItem{
        1:string hsItemId,
        2:i64 itemId,
        3:string hsProductId,
        4:i64 listingPrice,
        5:i64 defaultWarehouseId
        6:i64 addedTimestamp,
        7:string addedBy
}

struct BulkItemPricing{
        1:i64 item_id,
        2:i64 quantity,
        3:double price,
        4:i64 id
}

struct DtrPricing{
        1:double sellingPrice,
        2:map<i64, double> bulkPricing,
        3:i64 catalog_item_id,
        4:i64 minimumBuyQuantity,
        5:i64 maximumBuyQuantity
}

struct ItemPricing{
        1:i64 item_id,
        2:double selling_price,
        3:double mrp,
        4:i64 preferred_vendor,
        5:double private_deal_price,
        6:double weight
}

struct BulkUploadCatalog{
        1:i64 catalog_item_id,
        2:string brand,
        3:string model_name,
        4:string model_number
}

enum ItemCondition{
        DAMAGED,
        DEFECTIVE
}

service CatalogService extends GenericService.GenericService{

/**
        Availability and inventory attributes   
*/
        //all add and update methods - added by Ashish
        i64 addItem(1:Item item) throws (1:CatalogServiceException cex),
        i64 updateItem(1:Item item) throws (1:CatalogServiceException cex),
        
        /**
        Checks if the item given to the corresponding itemId is active. If it's active,
        whether it's risky and if it's risky, its inventory position.
        */
        ItemShippingInfo isActive(1:i64 itemId) throws (1:CatalogServiceException isex),

        map<i64, bool> getItemsStatus(1:list<i64> itemIds) throws (1:CatalogServiceException isex),
        
        string getItemStatusDescription(1:i64 itemId) throws (1:CatalogServiceException isex),
        
        //Item management apis
        void startItemOn(1:i64 item_id, 2:i64 timestamp) throws (1:CatalogServiceException cex),
        void retireItemOn(1:i64 item_id, 2:i64 timestamp) throws (1:CatalogServiceException cex),
        void changeItemStatus(1:i64 item_id, 2:i64 timestamp, 3:status newstatus) throws (1:CatalogServiceException cex),
        //Other accessor methods - added by Ashish
        Item getItem(1:i64 item_id) throws (1:CatalogServiceException cex),
        map<i64, Item> getItems(1:list<i64> item_ids) throws (1:CatalogServiceException cex),
        list<Item> getItemsByCatalogId(1:i64 catalog_item_id) throws  (1:CatalogServiceException cex),
        list<Item> getValidItemsByCatalogId(1:i64 catalog_item_id) throws  (1:CatalogServiceException cex),
        list<Item> getAllItems(1:bool isActive) throws (1:CatalogServiceException cex),
        list<Item> getAllItemsByStatus(1:status itemStatus) throws (1:CatalogServiceException cex),
        bool markItemAsContentComplete(1:i64 entityId, 2:i64 category, 3:string brand, 4:string modelName, 5:string modelNumber, 6:bool isAndroid) throws (1:CatalogServiceException cex),
        map<i64, double> getVatRates(1:i64 itemId, 2:i64 categoryId) throws (1:CatalogServiceException cex),
        
        /**
        Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
        */
        list<Item> getAllItemsInRange(1:i64 offset, 2:i64 limit) throws (1:CatalogServiceException cex),
        
        /**
        Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
        */
        list<Item> getAllItemsByStatusInRange(1:status itemStatus, 2:i64 offset, 3:i64 limit) throws (1:CatalogServiceException cex),
        
        /**
        Gets a count of all items by status
        */
        i32 getItemCountByStatus(1:bool useStatus, 2:status itemStatus),
        
        // for home page .... best deals, best sellers and latest arrivals
        list<Item> getBestSellers() throws (1:CatalogServiceException isex),
        list<i64> getBestSellersCatalogIds(1:i64 beginIndex, 2:i64 totalItems, 3:string brand, 4:i64 category) throws (1:CatalogServiceException cex),
        i64 getBestSellersCount() throws (1:CatalogServiceException cex),
        
        list<Item> getBestDeals() throws (1:CatalogServiceException isex),
        list<i64> getBestDealsCatalogIds(1:i64 beginIndex, 2:i64 totalItems, 3:string brand, 4:i64 category) throws (1:CatalogServiceException cex),
        i64 getBestDealsCount() throws (1:CatalogServiceException cex),

        list<Item> getComingSoon() throws (1:CatalogServiceException isex),
        list<i64> getComingSoonCatalogIds(1:i64 beginIndex, 2:i64 totalItems, 3:string brand, 4:i64 category) throws (1:CatalogServiceException cex),
        i64 getComingSoonCount() throws (1:CatalogServiceException cex),
        
        /**
        Returns a list of items sorted in the descending order by start date.
        The list is limited to the 'latest_arrivals_count' configuraiton parameter.
        */
        list<Item> getLatestArrivals() throws (1:CatalogServiceException isex),

        /**
        Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
        To ignore the categories, pass the list as empty. To ignore brand, pass it as null.   
        */
        list<i64> getLatestArrivalsCatalogIds(1:i64 beginIndex, 2:i64 totalItems, 3:string brand, 4:list<i64> categories) throws (1:CatalogServiceException cex),
        
        /**
        Get the total number of latest arrivals we are willing to show.
        The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
        */
        i64 getLatestArrivalsCount() throws (1:CatalogServiceException cex),
        
        
        i64 generateNewEntityID(),
        
        /**
        * All category related functions
        */
        bool addCategory(1:Category category),
        Category getCategory(1:i64 id),
        list<Category> getAllCategories(),
        
        /**
        Returns the list of similar items.
        */
        list<Item> getAllSimilarItems(1:i64 itemId),
        
        /**
        Adds similar item.
        */
        Item addSimilarItem(1:i64 itemId, 2:i64 catalogItemId) throws (1:CatalogServiceException cex),
        
        /**
        Tag Related
        */
        
        bool addTag(1:string displayName, 2:i64 itemId),
        bool deleteEntityTag(1:string displayName, 2:i64 itemId),
        bool deleteTag(1:string displayName),
        list<string> getAllTags(),
        list<i64> getAllEntitiesByTagName(1:string displayName)
        map<i64, list<string>> getAllEntityTags()
        
        /**
        Banner Related
        */
        
        bool addBanner(1:BannerCongregate bannerCongregate),
        bool updateBanner(1:Banner banner),
        list <Banner> getAllBanners(),
        bool deleteBanner(1:string bannerName,2:BannerType bannerType),
        Banner getBannerDetails(1:string bannerName,2:BannerType bannerType),
        map<string,list<Banner>> getActiveBanners(),
        bool addBannerMap(1:list<BannerMap> bannerMaps),
        bool updateBannerMap(1:BannerMap bannerMap),
        bool deleteBannerMap(1:string bannerName),
        list <BannerMap> getBannerMapDetails(1:string bannerName,2:BannerType bannerType),
        void addBannerUri(1:list<BannerUriMapping> bannerUriMappings),
        list<BannerUriMapping> getUriMapping(1:string bannerName,2:BannerType bannerType),
        void addCampaign(1:Campaign campaign),
        list<Campaign> getCampaigns(1:string campaignName),
        void deleteCampaign(1:i64 campaignId),
        list<string> getAllCampaigns(),
        map<string,list<Banner>> getActiveBannersForMobileSite(),
        /**
        Delete similar item.
        */
        bool deleteSimilarItem(1:i64 itemId, 2:i64 catalogItemId) throws (1:CatalogServiceException cex),
        
        /**
        Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
        If yes, returns the itemId else returns 0
        */
        i64 checkSimilarItem(1:string brand, 2:string modelNumber, 3:string modelName, 4:string color),
        
        /**
        Check wether item is risky and change status if inventory is not available for risky items
        */
        void validateRiskyStatus(1:i64 itemId),
        
        /**
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
    */
    void changeItemRiskyFlag(1:i64 itemId, 2:bool risky),
    
    
        /**
        Returns list of items marked as risky.
        */
        list<Item> getItemsByRiskyFlag(),
        
        /**
        Returns list of items with any status except PHASED_OUT and filtered by category, brand.
        */
        list<Item> getItemsForMasterSheet(1:string category, 2:string brand),
        
        /**
        Returns list of catalog ids of items with same similarity index as of the given itemId 
        */
        list<i64> getSimilarItemsCatalogIds(1:i64 beginIndex, 2:i64 totalItems, 3:i64 itemId),

        /**
        Add user requests for out of stock items. Once user will ask for notify me an entry will 
        */
        bool addProductNotification(i64 itemId, string email),
        
        /**
                Send the product notifications to the users for items which has stock.
        */
        bool sendProductNotifications(),
        
        /**
                Returns list of brand names for a given category Id
        */
        list<string> getAllBrandsByCategory(1:i64 categoryId),
    
    /**
                Returns list of brand names
        */
        list<string> getAllBrands(),
    
        /**
        Return list of all sources
        */
        list<Source> getAllSources(), 
                
        /**
        Returns the pricing information of an item. If no information is found, exception will be thrown.
        */
        SourceItemPricing getItemPricingBySource(1:i64 itemId, 2:i64 sourceId) throws (1:CatalogServiceException cex),
        
        /**
        Adds prices to be displayed corresponding to the item if user comes from a source.
        If item is not found or source is not found, it will throw exception.
        */
        void addSourceItemPricing(1:SourceItemPricing sourceItemPricing) throws (1:CatalogServiceException cex),
        
        /**
        Returns the list of source pricing information of an item.
        Raises an exception if item not found corresponding to itemId
        */
        list<SourceItemPricing> getAllSourcePricing(1:i64 itemId) throws (1:CatalogServiceException cex),
        
        /**
        Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
        */
        Item getItemForSource(1:i64 item_id, 2:optional i64  sourceId) throws (1:CatalogServiceException cex),
        
        /**
        Searches items matching the the given terms in the catalog and returns results within the specified range.
        */
        list<Item> searchItemsInRange(1:list<string> searchTerms, 2:i64 offset, 3:i64 limit),
        
        /**
        Gets the count of search results for the given search terms so that the user can go through all the pages.
        */
        i32 getSearchResultCount(1:list<string> searchTerms),
        
        /**
        Returns a list of product notifications added after a supplied datetime
        */
        list<ProductNotificationRequest> getProductNotifications(1:i64 startDateTime),
        
        /**
        Returns a list of count of requests for product notification against each item
        */
        list<ProductNotificationRequestCount> getProductNotificationRequestCount(1:i64 startDateTime, 2:i64 categoryId);
        
        /**
        This method adds a log to authorize table with Item Id, username who authorized the change, reason.
        */
        bool addAuthorizationLog(1:i64 itemId, 2:string username, 3:string reason) throws (1:CatalogServiceException cex),
        
        bool addupdateVoucherForItem(1:i64 catalog_item_id, 2:i64 voucherType, 3:i64 voucherAmount) throws (1:CatalogServiceException cex),
        
        bool deleteVoucherForItem(1:i64 catalog_item_id, 2:i64 voucherType) throws (1:CatalogServiceException cex),
        
        i64 getVoucherAmount(1:i64 itemId, 2:i64 voucherType),
        
        list<VoucherItemMapping> getAllItemVouchers(1:i64 itemId),
        
        bool isValidCatalogItemId(1:i64 catalog_item_id),
        
        double getVatPercentageForItem(1:i64 itemId, 2:i64 stateId, 3:double price) throws (1:CatalogServiceException cex),
        
        double getVatAmountForItem(1:i64 itemId, 2:double price),
        
        list<Item> getAllIgnoredInventoryUpdateItemsList(1:i32 offset,2:i32 limit),

        list<Item> getAllAliveItems();  
        
        /**
        This method returns the insurance amount needed to insure the given item for a given quantity.
        */
        i64 getInsuranceAmount(1:i64 itemId, 2:double price, 3:i64 insurerId, 4:i64 quantity),
        
        Insurer getInsurer(1:i64 insurerId),
        
        list<Insurer> getAllInsurers(),
        
        void updateInsuranceDeclaredAmount(1:i64 insurerId, 2:double amount),
        
        i64 getFreebieForItem(1:i64 itemId),
        
        void addOrUpdateFreebieForItem(1:FreebieItem freebieItem),
        
        void addOrUpdateBrandInfo(1:BrandInfo brandInfo),
        
        map<string, BrandInfo> getBrandInfo(),
        
        StorePricing getStorePricing(1:i64 itemId),
        
        list<StorePricing> getStorePricings(1:list<i64> itemIds),
        
        void updateStorePricing(1:StorePricing sp, 2:bool allColors),
        
        list<Amazonlisted> getAllAmazonListedItems(),
        
        list<Amazonlisted> searchAmazonItems(1:list<string> searchTerm,2:i64 offset,3:i64 limit),
        
        i64 getAmazonSearchResultCount(1:list<string> searchTerm),
        
        i64 getCountForAmazonlistedItems(),
        
        Amazonlisted getAmazonItemDetails(1:i64 itemId),
        
        void updateAmazonItemDetails(1:Amazonlisted amazonlisted),
        
        void addAmazonItem(1:Amazonlisted amazonlisted),
        
        list<Item> getAsinItems(),
        
        list<Amazonlisted> getAllFbaListedItems(),
        
        list<Amazonlisted> getAllNonFbaListedItems(),
        
        bool updateItemInventory(1:i64 itemId, 2:i64 holdInventory, 3:i64 defaultInventory),
        
        bool updateTimestampForAmazonFeeds(1:string type, 2: list<i64> sku, 3:i64 timestamp)
        
        list<Category> getAllParentCategories()
        
        void addPageViewEvent(1:PageViewEvents pageViewEvents)
        
        void addCartEvent(1:CartEvents cartEvents)
        
        void addEbayItem(1:EbayItem ebayItem)
        
        EbayItem getEbayItem(1:string listingId)
        
        void updateEbayItem(1:EbayItem ebayItem)

        list<Amazonlisted> getAmazonListedItems(1:i64 offset,2:i64 limit)
        
        bool updateAmazonAttributesInBulk(1:map<i64, Amazonlisted> amazonlisted)
        
        list<Amazonlisted> getAllItemstoListOnFba()
        
        list<Amazonlisted> getAllItemstoListOnNonFba()
        
        void updateAsin(1:map<i64, Item> item)
        
        bool addOrUpdateSnapdealItem(SnapdealItem snapdealitem)
        
        SnapdealItem getSnapdealItem(1:i64 item_id)
        
        SnapdealItemDetails getSnapdealItemDetails(1:i64 item_id)
        
        list<SnapdealItemDetails> getAllSnapdealItems()
        
        list<SnapdealItemDetails> getSnapdealItems(1:i64 offset,2:i64 limit)
        
        list<SnapdealItemDetails> searchSnapdealItems(1:list<string> searchTerm,2:i64 offset,3:i64 limit)
        
        i64 getCountForSnapdealItems()
        
        i64 getSnapdealSearchResultCount(1:list<string> searchTerm)
        
        i64 getPrefferedInsurerForItem(1:i64 itemId, 2:InsurerType insurerType)
        
        SnapdealItem getSnapdealItembySkuAtSnapdeal(string skuAtSnapdeal)
        
        ProductFeedSubmit getProductFeedSubmit(1:i64 catalogItemId) throws (1:CatalogServiceException cex),
        
        bool addProductFeedSubmit(1:ProductFeedSubmit productFeedSubmit) throws (1:CatalogServiceException cex),
        
        bool updateProductFeedSubmit(1:ProductFeedSubmit productFeedSubmit) throws (1:CatalogServiceException cex),

        bool deleteProductFeedSubmit(1:i64 catalogItemId) throws (1:CatalogServiceException cex),
        
        list<ProductFeedSubmit> getAllProductFeedSubmit() throws (1:CatalogServiceException cex)
        
        MarketplaceItems getMarketplacedetailsForItem(1:i64 itemId,2:i64 sourceId)
        
        bool updateMarketplaceAttributesForItem(1:MarketplaceItems marketPlaceItem)
        
        MarketplacePercentage getCostingForMarketplace(1:i64 source,2:i64 item_id)
        
        list<MarketPlaceItemPrice> getMarketPlaceItemsForPriceUpdate(1:i64 source),
        
        void updateMarketPlacePriceUpdateStatus(1:list<i64> skulist,2:i64 timestamp,3:i64 source),
        
        void updateItemHoldInventory(1:map<i64,i64> itemHoldMap),       
        
        void updateNlcAtMarketplaces(1:i64 item_id,2:i64 vendor_id,double nlc),
        
        list<FlipkartItem> getAllFlipkartItems(),
        
        bool addOrUpdateFlipkartItem(FlipkartItem flipkartitem),
        
        FlipkartItem getFlipkartItem(1:i64 item_id),
        
        FlipkartItemDetails getFlipkartItemDetails(1:i64 item_id),
        
        list<FlipkartItemDetails> getFlipkartItems(1:i64 offset,2:i64 limit),
        
        list<FlipkartItemDetails> searchFlipkartItems(1:list<string> searchTerm,2:i64 offset,3:i64 limit),
        
        i64 getCountForFlipkartItems(),
        
        i64 getFlipkartSearchResultCount(1:list<string> searchTerm),
        
        list<FlipkartItemDetails> getAllFkItems()
        
        FlipkartItem getFlipkartItemBySkyAtFlipkart(string sku)
        
        list<MarketplaceHistory> getMarketplaceHistory(1:i64 source,2:i64 offset,3:i64 itemId),
        
        list<Amazonlisted> getAllFbbListedItems()
        
        list<Amazonlisted> getAllFbbPricingItems()
        
        i64 getCountForMarketplaceHistory(1:i64 source,2:i64 itemId)
        
        list<MarketplaceHistory> getMarketplaceHistoryByDate(1:i64 source,2:i64 startDate,3:i64 endDate,4:i64 offset,5:i64 limit,6:i64 itemId)
        
        PrivateDeal getPrivateDealDetails(1:i64 item_id)
        
        list<Item> getPrivateDealItems(1:i64 offset,2:i64 limit)
        
        map<i64, PrivateDeal> getAllActivePrivateDeals(1:list<i64> itemIds, 2:i64 daysDelta)
        
        bool addOrUpdatePrivateDeal(1:PrivateDeal privateDeal)
        
        list<i64> getPrivateDealsCatalogIds(1:i64 beginIndex, 2:i64 totalItems) throws (1:CatalogServiceException cex),
        
        i32 getPrivateDealsCount(),
        
        AmazonOutOfSync getAmazonOutSyncItems(1:i64 item_id),
        
        list<PdPriceComp> getAllPrivateDealsComparison(),
        
        //list<DealTag> getAllDealTags() throws (1:CatalogServiceException cex)
        
        //list<ItemTag> getAllItemTagsByItemId(1:i64 itemId) throws (1:CatalogServiceException cex)
        
        //bool addUpdateItemTag(1:ItemTag itemTag, 2:bool makeStatusInactive) throws (1:CatalogServiceException cex)
        
        list<SnapdealItem> getAllSnapdealMarketplaceItem(),
        
        list<FlipkartItem> getAllFlipkartMarketplaceItem(),
        
        void addCompetitorScraping(1:map<i64,CompetitorPricing> competitorPricingMap),
        
        list<CompetitorPricing> getPreviousCompetitorScraping(1:i64 delta),
        
        list<CompetitorPricing> getUploadResultById(1:i64 uploadId),
        
        list<string> addAmazonPromotion(1:map<string,AmazonPromotion> amazonPromotions) throws (1:CatalogServiceException cex),
        
        list<AmazonPromotion> getAmazonPromotion(1:i64 startDate,2:i64 endDate),
        
        bool updateAmazonPromotion(1:list<AmazonPromotion> amazonPromotions),
        
        bool markPartiallyActive(1:i64 itemId, 2:i64 categoryId),
        
        bool updateItemStateVat(1:i64 itemId, 2:map<i64,double> statevat)
        
        map<i64, ExclusiveAffiliateItemInfo> getExAffiliateItemInfo()
        
        list<Amazonlisted> getAllItemstoListOnFbg()
        
        list<Amazonlisted> getAllFbgListedItems()
        
        map<i64, map<string,i64>> checkServices(1:map<i64,map<string,i64>> lines) throws (1:CatalogServiceException cex)
        
        void addHsItem(1:list<HsItem> hsItems)
        
        HsItem getHsItem(1:string hsItemId)
        
        void updateHsItem(1:HsItem hsItem)
        
        DtrPricing getPricingForDtr(1:i64 catalogItemId)
        
        list<Amazonlisted> getAllItemstoListOnFbd()
        
        list<Amazonlisted> getAllFbdListedItems()
        
        map<i64,list<BulkItemPricing>> getBulkPricingForItems(1:list<i64> itemIds)
        
        BulkItemPricing addBulkPricingForItem(1:BulkItemPricing bulkItemPricing);
        
        bool deleteBulkPricingForItemById(1:i64 id);
        
        bool deleteBulkPricingForItem(1:i64 item_id);
        
        list<BulkItemPricing> getBulkPricingByItemId(1:i64 item_id);
        
        bool updateBulkPricesOnProduction(1:i64 item_id, 2:list<BulkItemPricing> bulkItemPricingList);
        
        list<i64> getCartByValue(1:list<i64> cartIds)
        
        bool updateItemPricing(1:list<ItemPricing> itemPricingList)
        
        void bulkUpdateCatalog(1:list<BulkUploadCatalog> bulkUploadCatalog) throws (1:CatalogServiceException cex)
        
        map<string, i64> getWarrantyInfoForItem(1:i64 catalogItemId, 2:ItemCondition itemCondition) throws (1:CatalogServiceException cex)
        
        map<i64, map<string, i64>> getWarrantyInfoForItemList(1:list<i64> catalogItemIds, 2:ItemCondition itemCondition) throws (1:CatalogServiceException cex)
        
        //StateGstRates getGstRatesByState(1:i64 stateId) throws (1:CatalogServiceException cex)
        
        map<i64, GstRate> getStateTaxRate(1:list<i64> itemIds, 2:i64 stateId)
        
        map<i64, double> getIgstTaxRate(1:list<i64> itemIds)
        
        void persistGstRate(1:list<StateGstRate> stateGstRates)
        
        //map<i32, double> getCgstTaxRate(1:list<i32> itemIds, 2:i32 stateId)
        
        //map<string, GstRate> getInterStateGstRates() throws (1:CatalogServiceException cex)
        
        list<CategoryHsnCode> getHsnCodesByCategory(1:i64  categoryId) throws(1:CatalogServiceException cex)
        
        map<i64,double> getAllFofoDeals(list<i64> itemIds, list<i64> tagIds)
        
}