Subversion Repositories SmartDukaan

'''
Created on 27-Apr-2010

@author: ashish
'''
import datetime

from shop2020.config.client.ConfigClient import ConfigClient
from shop2020.model.v1.catalog.impl.Convertors import to_t_item, to_t_category, \
    to_t_source_item_pricing, to_t_product_notification_request, to_t_banner, \
    to_t_banner_map, to_t_product_notification_request_count, \
    to_t_voucher_item_mapping, to_t_insurer, to_t_Amazonlisted, to_t_ebay_item, \
    to_t_uri_mapping, to_t_banner_list, to_t_campaign, to_t_snapdeal_item, \
    to_t_snapdeal_item_details, to_t_product_feed_submit, to_t_marketplace_items, \
    to_t_marketplace_itemprice, to_t_marketplacepercentage, to_t_flipkart_item, \
    to_t_flipkart_item_details, to_t_market_place_history, to_t_private_deal, \
    to_t_amazonoutofsync, to_t_private_deals_comparison, \
    to_t_snapdeal_marketplace_item, to_t_flipkart_marketplace_item, \
    to_t_competitor_pricing, to_t_amazon_promotion, to_t_Amazonlisted_promo, \
    to_t_hsItem, to_t_bulk_pricing, to_t_dtr_pricing
from shop2020.model.v1.catalog.impl.DataAcessors import add_item, retire_item, \
    change_item_status, get_item, get_all_items, get_all_items_by_status, \
    update_item, start_item_on, close_session, retire_item_on, \
    get_items_by_catalog_id, get_best_deals, get_best_deals_catalog_ids, \
    get_best_deals_count, get_best_sellers, get_latest_arrivals, \
    get_latest_arrivals_catalog_ids, get_latest_arrivals_count, is_active, \
    get_best_sellers_catalog_ids, get_best_sellers_count, put_category_object, \
    get_category_object, mark_item_as_content_complete, generate_new_entity_id, \
    get_category, get_all_categories, add_category, get_item_status_description, \
    check_similar_item, change_risky_flag, get_items_for_mastersheet, \
    get_risky_items, get_similar_items_catalog_ids, add_product_notification, \
    send_product_notifications, get_all_brands_by_category, is_alive, \
    get_item_pricing_by_source, add_source_item_pricing, get_all_sources, \
    get_item_for_source, get_all_source_pricing, get_item_count_by_status, \
    search_items, get_search_result_count, get_product_notifications, \
    get_product_notification_request_count, get_all_similar_items_catalog_ids, \
    add_similar_item_catalog_id, delete_similar_item_catalog_id, \
    add_authorization_log_for_item, get_thrift_item_list, get_all_brands, \
    get_coming_soon, get_coming_soon_catalog_ids, get_coming_soon_count, initialize, \
    add_update_voucher_for_item, delete_voucher_for_item, get_voucher_amount, \
    get_all_vouchers_for_item, is_valid_catalog_id, check_risky_item, \
    get_vat_percentage_for_item, get_vat_amount_for_item, add_tag, get_all_tags, \
    get_all_entities_by_tag_name, delete_tag, delete_entity_tag, \
    get_all_ignored_inventoryupdate_items_list, add_banner, get_all_banners, \
    delete_banner, get_banner_details, get_active_banners, add_banner_map, \
    delete_banner_map, get_banner_map_details, get_insurance_amount, get_insurer, \
    get_all_alive_items, get_all_insurers, get_all_entity_tags, \
    update_insurance_declared_amount, get_freebie_for_item, \
    add_or_update_freebie_for_item, get_all_amazon_listed_items, get_store_pricing, \
    update_store_pricing, get_amazon_item_details, update_amazon_item_details, \
    add_amazon_item, get_asin_items, get_all_fba_listed_items, \
    get_all_nonfba_listed_items, add_or_update_brand_info, get_brand_info, \
    get_items_status, update_item_inventory, update_timestamp_for_amazon_feeds, \
    get_all_parent_categories, add_page_view_event, add_cart_event, insert_ebay_item, \
    get_ebay_item, update_ebay_item, update_amazon_attributes_in_bulk, \
    get_all_items_to_list_on_fba, get_all_items_to_list_on_nonfba, update_banner, \
    add_banner_uri, get_uri_mapping, add_campaign, get_campaigns, delete_campaign, \
    get_all_campaigns, get_amazon_listed_items, search_amazon_items, \
    get_count_for_amazonlisted_items, get_amazon_search_result_count, update_asin, \
    add_or_update_snapdeal_item, get_snapdeal_item, get_all_snapdeal_items, \
    get_snapdeal_items, search_snapdeal_items, get_count_for_snapdeal_items, \
    get_snapdeal_search_result_count, get_active_banners_for_mobile_site, \
    get_preffered_insurer_for_item, get_snapdealitem_by_skuatsnapdeal, \
    get_product_feed_submit, add_product_feed_submit, update_product_feed_submit, \
    delete_product_feed_submit, get_all_product_feed_submit, \
    get_snapdeal_item_detail, get_marketplace_details_for_item, \
    update_marketplace_attributes_for_item, get_costing_for_marketplace, \
    get_all_marketplace_items_for_priceupdate, update_marketplace_priceupdate_status, \
    update_item_hold_inventory, update_nlc_at_marketplaces, get_all_flipkart_items, \
    get_flipkart_item, add_or_update_flipkart_item, get_flipkart_item_detail, \
    get_flipkart_items, search_flipkart_items, get_count_for_flipkart_items, \
    get_flipkart_search_result_count, get_all_fk_items, \
    get_flipkart_item_by_sku_at_flipkart, get_marketplace_history, \
    get_all_fbb_listed_items, get_count_for_marketplaceHistory, \
    get_marketplace_history_by_date, get_all_fbb_pricing_items, \
    get_private_deal_details, get_private_deal_items, add_or_update_private_deal, \
    get_all_active_private_deals, get_private_deals_catalog_ids, \
    get_private_deals_count, get_amazon_out_of_sync, \
    get_all_private_deals_comparison, get_all_snapdeal_marketplaceItem, \
    get_all_flipkart_marketplaceItem, add_competitor_scraping, \
    get_previous_competitor_scraping, get_upload_result_by_id, add_amazon_promotion, \
    get_amazon_promotion, update_amazon_promotion, get_vat_rates, \
    update_item_state_vat, mark_partially_active, get_ex_affiliate_item_info, \
    get_all_items_to_list_on_fbg, get_all_fbg_listed_items, check_services, \
    get_items, add_hs_item, get_hs_item, update_hs_item, get_pricing_for_dtr, \
    get_all_items_to_list_on_fbd, get_all_fbd_listed_items, \
    get_bulk_pricing_for_items, add_bulk_pricing_for_item, \
    get_bulk_pricing_by_item_id, delete_bulk_pricing_for_item_by_id, \
    delete_bulk_pricing_for_item, update_bulk_prices_on_production, \
    get_cart_by_value, update_item_pricing, bulk_update_catalog, \
    get_warranty_info_for_item, get_warranty_info_for_item_list, \
    get_gst_rates_by_state, get_interstate_gst_rates, get_hsn_codes_by_category, \
    get_all_fofo_deals, get_state_tax_rate, \
    get_igst_tax_rate, add_state_gst_rates
from shop2020.thriftpy.model.v1.catalog.ttypes import status, \
    CatalogServiceException
from shop2020.utils.Utils import log_entry, to_py_date


class CatalogServiceHandler:
    '''
    classdocs
    '''
    
    def __init__(self, dbname='catalog', db_hostname='localhost'):
        '''
        Constructor
        '''
        initialize(dbname, db_hostname)
        try:
            config_client = ConfigClient()
            self.latest_arrivals_limit = int(config_client.get_property("LATEST_ARRIVALS_LIMIT"));
            self.best_sellers_limit = int(config_client.get_property("BEST_SELLERS_LIMIT"))
        except:
            self.latest_arrivals_limit = 50
            self.best_sellers_limit = 50
       
    #DONE
    def addItem(self, item):
        """
        Availability and inventory attributes
        
        Parameters:
         - item
        """
        log_entry(self, "addItem called")
        try:
            return add_item(item)
        finally:
            close_session()
            
    
    def addTag(self, displayName, catalogId):
        result = False
        try:
            return add_tag(displayName, catalogId)
        except:
            result = True
        finally:
            close_session()
            return result
        
    def addBanner(self, bannerCongregate):
        try:
            return add_banner(bannerCongregate)
        finally:
            close_session()
        
    def getAllBanners(self):
        bannerList=[]
        try:
            for banner in get_all_banners():
                bannerList.append(to_t_banner(banner))
        finally:
            close_session()
            return bannerList
        
    def deleteBanner(self,name,bannerType):
        try:
            return delete_banner(name,bannerType)
        finally:
            close_session()
        
    def getBannerDetails(self,name,bannerType):
        result = None
        try:
            result = get_banner_details(name,bannerType)
            if result is not None:
                result = to_t_banner(result)
        finally:
            close_session()
            return result
            
    def getActiveBanners(self):
        active_banners = {}
        try:
            active_banners = get_active_banners()
        finally:
            close_session()
            return active_banners

    def addBannerMap(self, bannerMaps):
        try:
            return add_banner_map(bannerMaps)
        finally:
            close_session()
        
    def deleteBannerMap(self, name):
        try:
            return delete_banner_map(name)
        finally:
            close_session()
        
    def getBannerMapDetails(self,name,bannerType):
        banners=[]
        try:
            for result in get_banner_map_details(name,bannerType):
                if result is not None:
                    banners.append(to_t_banner_map(result))
        finally:
            close_session()
            return banners
    def updateBanner(self,banner):
        try:
            return update_banner(banner)
        finally:
            close_session()
    
    def addBannerUri(self,bannerUriMappings):
        try:
            add_banner_uri(bannerUriMappings)
        finally:
            close_session()
    
    def getUriMapping(self,bannerName,bannerType):
        uriMapping=[]
        try:
            for uri in get_uri_mapping(bannerName,bannerType):
                uriMapping.append(to_t_uri_mapping(uri))
        finally:
            close_session()
            return uriMapping
        
    def addCampaign(self,campaign):
        try:
            add_campaign(campaign)
        finally:
            close_session()
    
    def getCampaigns(self,campaignName):
        campaigns = []
        try:
            for campaign in get_campaigns(campaignName):
                campaigns.append(to_t_campaign(campaign))
        finally:
            close_session()
            return campaigns
    
    def deleteCampaign(self,campaignId):
        try:
            delete_campaign(campaignId)
        finally:
            close_session()
            
    def getAllCampaigns(self):
        campaigns = []
        try:
            for campaign in get_all_campaigns():
                campaigns.append(campaign[0])
        finally:
            close_session()
            return campaigns
        
    def getActiveBannersForMobileSite(self):
        active_banners = {}
        try:
            active_banners = get_active_banners_for_mobile_site()
            for bannerName,banners in active_banners.iteritems():
                active_banners[bannerName] = to_t_banner_list(banners)
        finally:
            close_session()
            return active_banners
        
    
    def getAllTags(self):
        result = []
        try:
            result = get_all_tags()
        except:
            result = True
        finally:
            close_session()
            return result
            
    def getAllEntitiesByTagName(self,displayName):
        result = []
        try:
            result = get_all_entities_by_tag_name(displayName)
        except:
            result = True
        finally:
            close_session()
            return result
        
    def deleteTag(self,displayName):
        result = False
        try:
            return delete_tag(displayName)
        except:
            result = True
        finally:
            close_session()
            return result
        
    def deleteEntityTag(self,displayName,catalogId):
        result = False
        try:
            return delete_entity_tag(displayName,catalogId)
        except:
            result = True
        finally:
            close_session()
            return result
    
    def isActive(self, item_id):
        """
        Parameters:
         - item_id
        """
        try:
            return is_active(item_id)
        finally:
            close_session()
    
    def getItemsStatus(self, item_ids):
        """
        Parameters:
         - item_id
        """
        try:
            return get_items_status(item_ids)
        finally:
            close_session()

    def getItemStatusDescription(self, itemId):
        """
        Parameters:
         - itemId
        """
        try:
            return get_item_status_description(itemId)
        finally:
            close_session()
    
    def retireItem(self, item_id):
        """
        Parameters:
        - item_id
        """
        log_entry(self, "retire item called")
        try:
            return retire_item(item_id)
        finally:
            close_session()

    def startItemOn(self, item_id, timestamp):
        """
        Parameters:
         - item_id
         - timestamp
        """
        try:
            start_item_on(item_id, timestamp)
        finally:
            close_session()

    def retireItemOn(self, item_id, timestamp):
        """
        Parameters:
         - item_id
         - timestamp
        """
        try:
            retire_item_on(item_id, timestamp)
        finally:
            close_session()

    def changeItemStatus(self, item_id, timestamp, newstatus):
        """
        Parameters:
         - item_id
         - timestamp
         - newstatus
        """
        log_entry(self, "change item status called")
        try:
            return change_item_status(item_id, newstatus)
        finally:
            close_session()


    def getItem(self, item_id):
        """
        Parameters:
         - item_id
        """
        log_entry(self, "item requested")
        try:
            item = to_t_item( get_item(item_id))
            return item
        finally:
            close_session()
    
    def getItems(self, item_ids):
        """
        Parameters:
         - item_ids
        """
        returnMap = {}
        items = get_items(item_ids)
        try:
            for item in items:
                item = to_t_item(item)
                returnMap[item.id]=item
            return returnMap
        finally:
                close_session()
    
    def getItemsByCatalogId(self, catalog_item_id):
        """
        Parameters:
        - catalog_item_id
        """
        log_entry(self, "item requested")
        try:
            return get_thrift_item_list(get_items_by_catalog_id(catalog_item_id))
        finally:
            close_session()

    def getValidItemsByCatalogId(self, catalog_item_id):
        """
        Parameters:
         - catalog_item_id
        """
        log_entry(self, "items requested for CatalogItem")
        try:
            return get_thrift_item_list(filter(is_valid, get_items_by_catalog_id(catalog_item_id)))
        finally:
            close_session()
    
    def isValidCatalogItemId(self, catalog_item_id):
        """
        Parameters:
         - catalog_item_id
        """
        try:
            return is_valid_catalog_id(catalog_item_id)
        finally:
            close_session()
    
    def getAllItems(self, isActive):
        """
        Parameters:
         - isActive
        """
        log_entry(self, "all items requested")
        try:
            items = get_all_items(isActive)
            ret_items = []
            for item in items:
                if item:
                    ret_items.append(to_t_item(item))
            return ret_items
        finally:
            close_session()
            
    def getAllItemsByStatus(self, itemStatus):
        """
        Parameters:
         - itemStatus
        """
        log_entry(self, "all items requested")
        try:
            items = get_all_items_by_status(itemStatus)
            ret_items = []
            for item in items:
                if item:
                    ret_items.append(to_t_item(item))
            return ret_items
        finally:
            close_session()
            
    def getAllAliveItems(self):
        """
        Parameters:
         - itemStatus
        """
        log_entry(self, "all non phased non deleted items requested")
        try:
            items = get_all_alive_items()
            ret_items = []
            for item in items:
                if item:
                    ret_items.append(to_t_item(item))
            return ret_items
        finally:
            close_session()
    

    def getAllBrandsByCategory(self, categoryId):
        """
        Parameters:
         - categoryId
        """
        try:
            return get_all_brands_by_category(categoryId)
        finally:
            close_session()
    
    def getAllBrands(self):
        try:
            return get_all_brands()
        finally:
            close_session()
        
    def getAllItemsInRange(self, offset, limit):
        """
        Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
    
        Parameters:
         - offset
         - limit
        """
        try:
            items = get_all_items(False, offset, limit)
            return [to_t_item(item) for item in items]
        finally:
            close_session()

    def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
        """
        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.
    
        Parameters:
         - itemStatus
         - offset
         - limit
        """
        log_entry(self, "all items requested")
        try:
            items = get_all_items_by_status(itemStatus, offset, limit)
            return [to_t_item(item) for item in items]
        finally:
            close_session()

    def getItemCountByStatus(self, useStatus, itemStatus):
        """
        Gets a count of all items by status
    
        Parameters:
         - useStatus
         - itemStatus
        """
        try:
            return get_item_count_by_status(useStatus, itemStatus)
        finally:
            close_session()

    def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
        """
        Parameters:
         - entityId
         - category
         - brand
         - modelName
         - modelNumber
         - isAndroid
        """
        try:
            return mark_item_as_content_complete(entityId, category, brand, modelName, modelNumber, isAndroid)
        finally:
            close_session()
            
    def updateItem(self, item):
        """
        Parameters:
         - item
        """
        log_entry(self, "addItem called")
        try:
            return update_item(item)
        finally:
            close_session()
            
    def getBestSellers(self, start_index=0, total_items=None, category=-1):
        try:
            if total_items is None:
                total_items = self.best_sellers_limit
            stop_index = start_index + total_items
            return get_best_sellers(start_index, stop_index, category)
        finally:
            close_session()
            
    def getBestSellersCatalogIds(self, start_index, total_items, brand, category=-1):
        """
        Parameters:
         - beginIndex
         - totalItems
        """
        try:
            if total_items is None:
                total_items = self.best_sellers_limit
            stop_index = start_index + total_items
            return get_best_sellers_catalog_ids(start_index, stop_index, brand, category)
        finally:
            close_session()
            
    def getBestSellersCount(self, ):
        try:
            return get_best_sellers_count()
        finally:
            close_session()
            
    def getBestDeals(self,):
        try:
            return get_best_deals()
        finally:
            close_session()
            
    def getBestDealsCatalogIds(self, start_index, total_items, brand,category=-1):
        """
        Parameters:
         - beginIndex
         - totalItems
        """
        try:
            stop_index = start_index + total_items
            return get_best_deals_catalog_ids(start_index, stop_index, brand, category)
        finally:
            close_session()
            
    def getBestDealsCount(self, ):
        try:
            return get_best_deals_count()
        finally:
            close_session()
            
    def getComingSoon(self,):
        try:
            return get_coming_soon()
        finally:
            close_session()
            
    def getComingSoonCatalogIds(self, start_index, total_items, brand,category=-1):
        """
        Parameters:
         - beginIndex
         - totalItems
        """
        try:
            stop_index = start_index + total_items
            return get_coming_soon_catalog_ids(start_index, stop_index, brand, category)
        finally:
            close_session()
            
    def getComingSoonCount(self, ):
        try:
            return get_coming_soon_count()
        finally:
            close_session()
            
    def getLatestArrivals(self,):
        try:
            return get_latest_arrivals(self.latest_arrivals_limit)
        finally:
            close_session()
    
    def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
        """
        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.
        
        Parameters:
         - beginIndex
         - totalItems
         - brand
         - categories
        """
        try:
            if beginIndex > self.latest_arrivals_limit:
                return []
            stopIndex = beginIndex + totalItems
            if stopIndex > self.latest_arrivals_limit:
                stopIndex = self.latest_arrivals_limit
            return get_latest_arrivals_catalog_ids(beginIndex, stopIndex, brand, categories)
        finally:
            close_session()
            
    def getLatestArrivalsCount(self, ):
        try:
            return get_latest_arrivals_count(self.latest_arrivals_limit)
        finally:
            close_session()

    def generateNewEntityID(self, ):
        try:
            return generate_new_entity_id()
        finally:
            close_session()
                    
    def putCategoryObject(self, object):
        """
        Parameters:
         - object
        """
        try:
            return put_category_object(object)
        finally:
            close_session()
            
    def getCategoryObject(self, ):
        try:
            return get_category_object()
        finally:
            close_session()
        
    def addCategory(self, category):
        """
        Parameters:
         - category
        """
        try:
            return add_category(category)
        finally:
            close_session()

    def getCategory(self, id):
        """
        Parameters:
         - id
        """
        try:
            return to_t_category(get_category(id))
        finally:
            close_session()

    def getAllCategories(self, ):
        try:
            categories = get_all_categories()
            return [to_t_category(category) for category in categories]
        finally:
            close_session()
                
    def getAllSimilarItems(self, itemId):
        """
        Returns list of similar items.
        
        Parameters:
         - itemId
        """
        try:
            return get_all_similar_items_catalog_ids(itemId)
        finally:
            close_session()
                
    def addSimilarItem(self, itemId, catalogItemId):
        """
        add similar item.
        
        Parameters:
         - itemId, catalogItemId
        """
        try:
            return add_similar_item_catalog_id(itemId, catalogItemId)
        finally:
            close_session()
    
    def deleteSimilarItem(self, itemId, catalogItemId):
        """
        delete similar items.
        
        Parameters:
         - itemId, catalogItemIds
        """
        try:
            return delete_similar_item_catalog_id(itemId, catalogItemId)
        finally:
            close_session()
    
    def getAllItemVouchers(self, itemId):
        """
        Returns list of vouchers.
        
        Parameters:
         - itemId
        """
        try:
            vouchers = get_all_vouchers_for_item(itemId)
            return [to_t_voucher_item_mapping(voucher) for voucher in vouchers]
        finally:
            close_session()
    
    def getVoucherAmount(self, itemId, voucherType):
        """
        Returns voucher amount.
        
        Parameters:
         - itemId, voucherType
        """
        try:
            return get_voucher_amount(itemId, voucherType)
        finally:
            close_session()
    
    def addupdateVoucherForItem(self, catalogItemId, voucherType, voucherAmount):
        """
        add or update voucher for item.
        
        Parameters:
         - catalogItemId, voucherType, voucherAmount
        """
        try:
            return add_update_voucher_for_item(catalogItemId, voucherType, voucherAmount)
        finally:
            close_session()
    
    def deleteVoucherForItem(self, catalogItemId, voucherType):
        """
        delete voucher for item.
        
        Parameters:
         - catalogItemId, voucherType
        """
        try:
            return delete_voucher_for_item(catalogItemId, voucherType)
        finally:
            close_session()

    def checkSimilarItem(self, brand, modelNumber, modelName, color):
        """
        Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
        If yes, returns the itemId else returns 0
        
        Parameters:
         - brand
         - modelNumber
         - modelName
         - color
        """
        try:
            return check_similar_item(brand, modelNumber, modelName, color)
        finally:
            close_session()

    def changeItemRiskyFlag(self, itemId, risky):
        """
        Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
        
        Parameters:
         - itemId
         - risky
        """
        try:
            change_risky_flag(itemId, risky)
        finally:
            close_session()
            
    def getItemsForMasterSheet(self, category, brand):
        """
        Returns list of items with any status except PHASED_OUT and filtered by category, brand.
        
        Parameters:
         - category
         - vendor
         - brand
        """
        try:
            return [to_t_item(item, deal_price) for item, deal_price in get_items_for_mastersheet(category, brand)]
        finally:
            close_session()

    def getItemsByRiskyFlag(self, ):
        """
        Returns list of items marked as risky.
        """
        try:
            return [to_t_item(item) for item in get_risky_items()]
        finally:
            close_session()

    def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
        """
        Returns list of catalog ids of items with same similarity index as of the given itemId
        
        Parameters:
         - beginIndex
         - totalItems
         - itemId
        """
        try:
            return get_similar_items_catalog_ids(beginIndex, beginIndex+totalItems, itemId)
        finally:
            close_session()

    def addProductNotification(self, itemId, email):
        """
        Add user requests for out of stock items. Once user will ask for notify me an entry will
        
        Parameters:
        - itemId
        - email
        """
        try:
            return add_product_notification(itemId, email)
        finally:
            close_session()
            
    def sendProductNotifications(self, ):
        """
        Send the product notifications to the users for items which has stock.
        """
        try:
            return send_product_notifications()
        finally:
            close_session()


    def getAllSources(self, ):
        """
        Return list of all sources
        """
        try:
            return get_all_sources()
        finally:
            close_session()

    def getItemPricingBySource(self, itemId, sourceId):
        """
        Returns the pricing information of an item. If no information is found, exception will be thrown.
    
        Parameters:
         - itemId
         - sourceId
        """
        try:
            return to_t_source_item_pricing(get_item_pricing_by_source(itemId, sourceId))
        finally:
            close_session()
            
    def addSourceItemPricing(self, sourceItemPricing):
        """
        Adds prices to be displayed corresponding to the item if user comes from a source.
    
        Parameters:
         - sourceItemPricing
        """
        try:
            add_source_item_pricing(sourceItemPricing)
        finally:
            close_session()

    def getAllSourcePricing(self, itemId):
        """
        Returns the list of source pricing information of an item.
        Raises an exception if item not found corresponding to itemId
        
        Parameters:
         - itemId
        """
        try:
            return [to_t_source_item_pricing(source_item_pricing) for source_item_pricing in get_all_source_pricing(itemId)]
#        return [to_t_item(item) for item in get_risky_items()]
        finally:
            close_session()
            
    def getItemForSource(self, item_id, sourceId):
        """
        Parameters:
         - item_id
         - sourceId
        """
        try:
            return to_t_item(get_item_for_source(item_id, sourceId))
        finally:
            close_session()
            
    def searchItemsInRange(self, searchTerms, offset, limit):
        """
        Searches items matching the the given terms in the catalog
    
        Parameters:
         - searchTerms
        """
        try:
            return [to_t_item(item) for item in search_items(searchTerms, offset, limit)]
        finally:
            close_session()
    
    def getSearchResultCount(self, searchTerms):
        """
        Gets the count of search results for the given search terms so that the user can go through all the pages.
    
        Parameters:
         - searchTerms
        """
        try:
            return get_search_result_count(searchTerms)
        finally:
            close_session()
    
    def getProductNotifications(self, startDateTime):
        '''
        Returns a list of Product Notification objects each representing user requests for notification
        '''
        try:
            return [to_t_product_notification_request(notification) for notification in get_product_notifications(to_py_date(startDateTime))]
        finally:
            close_session()
    
    def getProductNotificationRequestCount(self, startDateTime,  categoryId):
        '''
        Returns list of items and the counts of product notification requests
        '''
        try:
            notification_request_counts = [(notification.item, count) for notification, count in get_product_notification_request_count(to_py_date(startDateTime), categoryId)]
            
            return [to_t_product_notification_request_count(count) for count in notification_request_counts]
             
        finally:
            close_session()
    
    def isAlive(self, ):
        """
        For checking weather service is active alive or not. It also checks connectivity with database
        """
        try:
            return is_alive()
        finally:
            close_session()

    def closeSession(self, ):
        """
        For closing the open session in sqlalchemy
        """
        close_session()
        
    def addAuthorizationLog(self, itemId, username, reason):
        """
        add a log to authorize table.
        
        Parameters:
         - itemId, username, reason
        """
        try:
            return add_authorization_log_for_item(itemId, username, reason)
        finally:
            close_session()
    
    def getVatPercentageForItem(self, itemId, stateId, price):
        """
        get Vat percentage for item for item
        """
        try:
            return get_vat_percentage_for_item(itemId, stateId, price)
        finally:
            close_session()

    def getVatAmountForItem(self, itemId, price):
        """
        get Vat amount for item
        """
        try:
            return get_vat_amount_for_item(itemId,price)
        finally:
            close_session()
    
    def validateRiskyStatus(self, itemId):
        """
        Check wether item is risky and change status if inventory is not available for risky items
        """
        try:
            return check_risky_item(itemId)
        finally:
            close_session()
            
    def getAllIgnoredInventoryUpdateItemsList(self,offset, limit):
        try:
            return get_all_ignored_inventoryupdate_items_list(offset,limit)
        finally:
            close_session()
            
    def getInsuranceAmount(self, itemId, price, insurerId, quantity):
        try:
            return get_insurance_amount(itemId, price, insurerId, quantity)
        finally:
            close_session()
            
    def getInsurer(self, insurerId):
        try:
            return to_t_insurer(get_insurer(insurerId))
        finally:
            close_session()
            
    def getAllInsurers(self):
        try:
            insurers = []
            all_insurers = get_all_insurers()
            for insurer in all_insurers:
                insurers.append(to_t_insurer(insurer))
            return insurers
        finally:
            close_session()
            
    def getPrefferedInsurerForItem(self, itemId, insurerType):
        try:
            return get_preffered_insurer_for_item(itemId, insurerType)
        finally:
            close_session()

    def updateInsuranceDeclaredAmount(self, insurerId, amount):
        try:
            update_insurance_declared_amount(insurerId, amount)
        finally:
            close_session()
    
    def getAllEntityTags(self):
        try:
            return get_all_entity_tags()
        finally:
            close_session()
    
    def getFreebieForItem(self, itemId):
        try:
            return get_freebie_for_item(itemId)
        finally:
            close_session()
    
    def addOrUpdateFreebieForItem(self, freebieItem):
        try:
            return add_or_update_freebie_for_item(freebieItem)
        finally:
            close_session()
            
    def addOrUpdateBrandInfo(self, brandInfo):
        try:
            return add_or_update_brand_info(brandInfo)
        finally:
            close_session()

    def getBrandInfo(self):
        try:
            return get_brand_info()
        finally:
            close_session()

    def getStorePricing(self, itemId):
        try:
            return get_store_pricing(itemId)
        finally:
            close_session()

    def getStorePricings(self, itemIds):
        try:
            return [get_store_pricing(itemId) for itemId in itemIds]
        finally:
            close_session()

    def updateStorePricing(self, sp, allColors):
        try:
            return update_store_pricing(sp, allColors)
        finally:
            close_session()
            
    def getAmazonItemDetails(self, amazonItemId):
        try:
            return to_t_Amazonlisted_promo(get_amazon_item_details(amazonItemId))
        finally:
            close_session()
        
    def updateAmazonItemDetails(self,amazonlisted):
        try:
            update_amazon_item_details(amazonlisted)
        finally:
            close_session()
            
    def addAmazonItem(self,amazonlisted):
        try:
            add_amazon_item(amazonlisted)
        finally:
            close_session()
        
    def getAsinItems(self):
        try:
            items = get_asin_items()
            ret_items = []
            for item in items:
                if item:
                    ret_items.append(to_t_item(item))
            return ret_items
        finally:
            close_session()
            
    def getAllFbaListedItems(self):
        try:
            items = get_all_fba_listed_items()
            ret_items = []
            for item in items:
                if item:
                    ret_items.append(to_t_Amazonlisted(item))
            return ret_items
        finally:
            close_session()
        
    def getAllNonFbaListedItems(self):
        try:
            items = get_all_nonfba_listed_items()
            ret_items = []
            for item in items:
                if item:
                    ret_items.append(to_t_Amazonlisted(item))
            return ret_items
        finally:
            close_session()
   
             
    def getAllAmazonListedItems(self):      
        try:
            amazonlisteditems = []
            all_listed = get_all_amazon_listed_items()
            for amazonlisteditem in all_listed:
                amazonlisteditems.append(to_t_Amazonlisted(amazonlisteditem))
            return amazonlisteditems
        finally:
            close_session()           
            
    def updateItemInventory(self,itemId,holdInventory,defaultInventory):
        try:
            update_item_inventory(itemId,holdInventory,defaultInventory)
            return True
        finally:
            close_session()
            
    def updateTimestampForAmazonFeeds(self,feedType,skuList,timestamp):
        try:
            return update_timestamp_for_amazon_feeds(feedType,skuList,timestamp)
        finally:
            close_session()
            
    def  getAllParentCategories(self):
        try:
            categories = get_all_parent_categories()
            return [to_t_category(category) for category in categories]
        finally:
            close_session()
            
    def addPageViewEvent(self,pageEvent):
        try:
            add_page_view_event(pageEvent)
        finally:
            close_session()
            
    def addCartEvent(self,cartEvent):
        try:
            add_cart_event(cartEvent)
        finally:
            close_session()

    def addEbayItem(self, ebayItem):
        try:
            insert_ebay_item(ebayItem)
        finally:
            close_session()
        
    def getEbayItem(self, listingId):
        try:
            return to_t_ebay_item(get_ebay_item(listingId))
        finally:
            close_session()
            
    def updateEbayItem(self, ebayItem):
        try:
            update_ebay_item(ebayItem)
        finally:
            close_session()
                
    def updateAmazonAttributesInBulk(self,amazonlisted):
        try:
            return update_amazon_attributes_in_bulk(amazonlisted)
        finally:
            close_session()
            
    def getAllItemstoListOnFba(self):
        try:
            fba_items = []
            for item in get_all_items_to_list_on_fba():
                fba_items.append(to_t_Amazonlisted(item))
            return fba_items
        finally:
            close_session()

    def getAllItemstoListOnNonFba(self):
        try:
            non_fba_items = []
            for item in get_all_items_to_list_on_nonfba():
                non_fba_items.append(to_t_Amazonlisted(item))
            return non_fba_items
        finally:
            close_session()
            
    def getAmazonListedItems(self,offset,limit):
        try:
            amazonlisteditems = []
            all_listed = get_amazon_listed_items(offset,limit)
            for amazonlisteditem in all_listed:
                amazonlisteditems.append(to_t_Amazonlisted(amazonlisteditem))
        finally:
            close_session()
            return amazonlisteditems
        
    def searchAmazonItems(self,searchTerms,offset,limit):
        try:
            amazonlisteditems = []
            search_result = search_amazon_items(searchTerms,offset,limit)
            for amazonlisteditem in search_result:
                amazonlisteditems.append(to_t_Amazonlisted(amazonlisteditem))
        finally:
            close_session()
            return amazonlisteditems
    
    def getAmazonSearchResultCount(self,searchTerms):
        try:
            return get_amazon_search_result_count(searchTerms)
        finally:
            close_session()
    
    def getCountForAmazonlistedItems(self):
        try:
            return get_count_for_amazonlisted_items()
        finally:
            close_session()
    
    def updateAsin(self,amazonAsinMap):
        try:
            update_asin(amazonAsinMap)
        finally:
            close_session()
            
    def addOrUpdateSnapdealItem(self,snapdealitem):
        try:
            return add_or_update_snapdeal_item(snapdealitem)
        finally:    
            close_session()
            
    def getSnapdealItem(self,item_id):
        try:
            return to_t_snapdeal_item(get_snapdeal_item(item_id))
        finally:
            close_session()
    
    def getSnapdealItemDetails(self,item_id):
        try:
            snapdealItem, snapdealInventory = get_snapdeal_item_detail(item_id)
            return to_t_snapdeal_item_details(snapdealItem, snapdealInventory)
        finally:
            close_session()
            
    def getAllSnapdealItems(self):
        try:
            items = get_all_snapdeal_items() 
            return [to_t_snapdeal_item_details(item,None) for item in items]
        finally:
            close_session()
            
    def getSnapdealItems(self,offset,limit):
        try:
            items = get_snapdeal_items(offset,limit) 
            return [to_t_snapdeal_item_details(item,None) for item in items]
        finally:
            close_session()
            
    def searchSnapdealItems(self,searchterm,offset,limit):
        try:
            snapdealitems = []
            search_result = search_snapdeal_items(searchterm,offset,limit)
            for snapdealitem in search_result:
                snapdealitems.append(to_t_snapdeal_item_details(snapdealitem,None))
        finally:
            close_session()
            return snapdealitems
    
    def getCountForSnapdealItems(self):
        try:
            return get_count_for_snapdeal_items()
        finally:
            close_session()
            
    
    def getSnapdealSearchResultCount(self,searchterms):
        try:
            return get_snapdeal_search_result_count(searchterms)
        finally:
            close_session()
            
    def getSnapdealItembySkuAtSnapdeal(self,skuatsnapdeal):
        try:
            return to_t_snapdeal_item(get_snapdealitem_by_skuatsnapdeal(skuatsnapdeal))
        finally:
            close_session()
    
    def getMarketplacedetailsForItem(self,itemId,sourceId):
        try:
            return to_t_marketplace_items(get_marketplace_details_for_item(itemId,sourceId))
        finally:
            close_session()
    
    def updateMarketplaceAttributesForItem(self,marketplaceItem):
        try:
            return update_marketplace_attributes_for_item(marketplaceItem)
        finally:
            close_session() 
            
    def getProductFeedSubmit(self, catalog_itemId):
        try:
            return to_t_product_feed_submit(get_product_feed_submit(catalog_itemId))
        finally:
            close_session()

    def addProductFeedSubmit(self, productFeedSubmit):
        try:
            return add_product_feed_submit(productFeedSubmit)
        finally:
            close_session()
    
    def updateProductFeedSubmit(self, productFeedSubmit):
        try:
            return update_product_feed_submit(productFeedSubmit)
        finally:
            close_session()
            
    def deleteProductFeedSubmit(self, catalog_itemId):
        try:
            return delete_product_feed_submit(catalog_itemId)
        finally:
            close_session()
    
    def getCostingForMarketplace(self, source, item_id):
        try:
            return to_t_marketplacepercentage(get_costing_for_marketplace(source, item_id))
        finally:
            close_session()
            
    def getAllProductFeedSubmit(self):
        try:
            log_entry(self, "all ProductFeedSubmit requested")
            feedSubmits = get_all_product_feed_submit()
            ret_feedSubmits = []
            for feedSubmit in feedSubmits:
                if feedSubmit:
                    ret_feedSubmits.append(to_t_product_feed_submit(feedSubmit))
            return ret_feedSubmits
        finally:
            close_session()
     
    def getMarketPlaceItemsForPriceUpdate(self,source):
        try:
            items = get_all_marketplace_items_for_priceupdate(source) 
            return [to_t_marketplace_itemprice(item) for item in items]
        finally:
            close_session()
            
    def updateMarketPlacePriceUpdateStatus(self,skulist,timestamp,source):
        try:
            update_marketplace_priceupdate_status(skulist,timestamp,source)
        finally:
            close_session()
    
    def updateItemHoldInventory(self,itemHoldMap):
        try:
            update_item_hold_inventory(itemHoldMap)
        finally:
            close_session()        
            
    def updateNlcAtMarketplaces(self,item_id,vendor_id,nlc):
        try:
            update_nlc_at_marketplaces(item_id,vendor_id,nlc)
        finally:
            close_session()
            
    def getAllFlipkartItems(self):
        try:
            return [to_t_flipkart_item(item) for item in get_all_flipkart_items()]
        finally:
            close_session()
    
    def getFlipkartItem(self,item_id):
        try:
            return to_t_flipkart_item(get_flipkart_item(item_id))
        finally:
            close_session()
    
    def addOrUpdateFlipkartItem(self,flipkartitem):
        try:
            return add_or_update_flipkart_item(flipkartitem)
        finally:    
            close_session()
    
    def getFlipkartItemDetails(self,item_id):
        try:
            flipkartitem, flipkartInventory = get_flipkart_item_detail(item_id)
            return to_t_flipkart_item_details(flipkartitem, flipkartInventory)
        finally:
            close_session()
    
    def getFlipkartItems(self,offset,limit):
        try:
            items = get_flipkart_items(offset,limit) 
            return [to_t_flipkart_item_details(item,None) for item in items]
        finally:
            close_session()
    
    def searchFlipkartItems(self,searchterm,offset,limit):
        flipkartitems = []
        try:
            search_result = search_flipkart_items(searchterm,offset,limit)
            for flipkartitem in search_result:
                flipkartitems.append(to_t_flipkart_item_details(flipkartitem,None))
        finally:
            close_session()
        return flipkartitems
    
    def getCountForFlipkartItems(self):
        try:
            return get_count_for_flipkart_items()
        finally:
            close_session()
    
    def getFlipkartSearchResultCount(self,searchterms):
        try:
            return get_flipkart_search_result_count(searchterms)
        finally:
            close_session()
    
    def getAllFkItems(self):
        try:
            return [to_t_flipkart_item_details(item,None) for item in get_all_fk_items()]
        finally:
            close_session()
    
    def getFlipkartItemBySkyAtFlipkart(self,sku):
        try:
            return to_t_flipkart_item(get_flipkart_item_by_sku_at_flipkart(sku))
        finally:
            close_session()
    
    def getMarketplaceHistory(self,source, offset, itemId):
        try:
            return [to_t_market_place_history(item) for item in get_marketplace_history(source, offset, itemId)]
        finally:
            close_session()    
    
    
    def getPrivateDealDetails(self,item_id):
        try:
            return to_t_private_deal(get_private_deal_details(item_id))
        finally:
            close_session()    
            
    def getAllActivePrivateDeals(self, itemIds=None, daysDelta=0):
        try:
            return get_all_active_private_deals(itemIds, daysDelta)
        finally:
            close_session()
    
    def getAllFbbListedItems(self):
        try:
            items = get_all_fbb_listed_items()
            ret_items = []
            for item in items:
                if item:
                    ret_items.append(to_t_Amazonlisted(item))
            return ret_items
        finally:
            close_session()
            
    def getAllFbbPricingItems(self):
        try:
            items = get_all_fbb_pricing_items()
            ret_items = []
            for item in items:
                if item:
                    ret_items.append(to_t_Amazonlisted(item))
            return ret_items
        finally:
            close_session()
                
    
    def getMarketplaceHistoryByDate(self,source,startDate,endDate,offset,limit,itemId):
        try:
            return [to_t_market_place_history(item) for item in get_marketplace_history_by_date(source,startDate,endDate,offset,limit,itemId)]
        finally:
            close_session()
    
    def getCountForMarketplaceHistory(self,source,itemId):
        try:
            return get_count_for_marketplaceHistory(source,itemId)
        finally:
            close_session()         
            
    def getPrivateDealItems(self,offset,limit):
        try:
            items = []
            for item in get_private_deal_items(offset,limit):
                items.append(to_t_item(item))
            return items 
        finally:
            close_session()
            
    def addOrUpdatePrivateDeal(self,privatedeal):                
        try:
            return add_or_update_private_deal(privatedeal)
        finally:
            close_session()
    
    def getPrivateDealsCatalogIds(self, start_index, total_items):
        """
        Parameters:
         - beginIndex
         - totalItems
        """
        try:
            return get_private_deals_catalog_ids(start_index, total_items)
        finally:
            close_session()
            
    def getPrivateDealsCount(self,):
        try:
            return get_private_deals_count()
        finally:
            close_session()
    
    def getAmazonOutSyncItems(self,item_id):
        try:
            return to_t_amazonoutofsync(get_amazon_out_of_sync(item_id))
        finally:
            close_session()
    
    def getAllPrivateDealsComparison(self):
        try:
            return [to_t_private_deals_comparison(item) for item in get_all_private_deals_comparison()]
        finally:
            close_session()
                
    '''        
    def getAllDealTags(self):
        try:
            return [to_t_deal_tag(dealTag) for dealTag in get_all_deal_tags()]
        finally:
            close_session()
            
    def addUpdateItemTag(self, itemTag, makeStatusInactive):
        log_entry(self, "addItemTag called")
        try:
            return add_update_item_tag(itemTag, makeStatusInactive)
        finally:
            close_session()
    
    def getAllItemTagsByItemId(self, itemId):
        log_entry(self, "get all Item tag called")
        try:
            ret_tags = []
            tags = get_all_item_tags_by_item_id(itemId)
            if tags:
                for tag in tags:
                    if tag:
                        ret_tags.append(to_t_item_tag(tag))
            return ret_tags
        finally:
            close_session()  
    '''        
    
    def getAllSnapdealMarketplaceItem(self):
        try:
            return [to_t_snapdeal_marketplace_item(item) for item in get_all_snapdeal_marketplaceItem()]
        finally:
            close_session()
    
    def getAllFlipkartMarketplaceItem(self):
        try:
            return [to_t_flipkart_marketplace_item(item) for item in get_all_flipkart_marketplaceItem()]
        finally:
            close_session()
    
    def addCompetitorScraping(self,competitorScrapingMap):
        try:
            add_competitor_scraping(competitorScrapingMap)
        finally:
            close_session()
    
    def getPreviousCompetitorScraping(self,delta):
        try:
            return get_previous_competitor_scraping(delta)
        finally:
            close_session()
    
    def getUploadResultById(self,uploadId):
        try:
            return [to_t_competitor_pricing(item) for item in get_upload_result_by_id(uploadId)]
        finally:
            close_session()
            
    def addAmazonPromotion(self,amazonPromotions):
        try:
            return add_amazon_promotion(amazonPromotions)
        except:
            raise CatalogServiceException(102, "Exception in adding amazon promotion") 
        finally:
            close_session()
    
    def getAmazonPromotion(self,startDate,endDate):
        try:
            return [to_t_amazon_promotion(amazonPromotion) for amazonPromotion in get_amazon_promotion(startDate,endDate)]
        finally:
            close_session()
    
    def updateAmazonPromotion(self,amazonPromotions):
        try:
            return update_amazon_promotion(amazonPromotions)
        except:
            return False
        finally:
            close_session()
            
    def getVatRates(self,itemId, categoryId):
        try:
            return get_vat_rates(itemId, categoryId)
        finally:
            close_session()
            
    def updateItemStateVat(self, itemId, stateVat):
        try:
            return update_item_state_vat(itemId, stateVat)
        except:
            return False
        finally:
            close_session()
            
    def markPartiallyActive(self, itemId, categoryId):
        try:
            mark_partially_active(itemId, categoryId)
        finally:
            close_session()
            return False
        
    def getExAffiliateItemInfo(self, ):
        return get_ex_affiliate_item_info()
    
    def getAllItemstoListOnFbg(self):
        try:
            fbg_items = []
            for item in get_all_items_to_list_on_fbg():
                fbg_items.append(to_t_Amazonlisted(item))
            return fbg_items
        finally:
            close_session()
            
    def getAllFbgListedItems(self):
        try:
            items = get_all_fbg_listed_items()
            ret_items = []
            for item in items:
                if item:
                    ret_items.append(to_t_Amazonlisted(item))
            return ret_items
        finally:
            close_session()

    def checkServices(self, map_lines):
        try:
            map_lines = check_services(map_lines)
            return map_lines
        finally:
            close_session()
    
    def addHsItem(self, hsItems):
        try:
            add_hs_item(hsItems)
        finally:
            close_session()
            
    def getHsItem(self, hsItemId):
        try:
            return to_t_hsItem(get_hs_item(hsItemId))
        finally:
            close_session()
    
    def updateHsItem(self, hsItem):
        try:
            update_hs_item(hsItem)
        finally:
            close_session()
    
    def getPricingForDtr(self,catalogItemId):
        try:
            return to_t_dtr_pricing(get_pricing_for_dtr(catalogItemId))
        finally:
            close_session()
            
    def getAllItemstoListOnFbd(self):
        try:
            fbd_items = []
            for item in get_all_items_to_list_on_fbd():
                fbd_items.append(to_t_Amazonlisted(item))
            return fbd_items
        finally:
            close_session()
            
    def getAllFbdListedItems(self):
        try:
            items = get_all_fbd_listed_items()
            ret_items = []
            for item in items:
                if item:
                    ret_items.append(to_t_Amazonlisted(item))
            return ret_items
        finally:
            close_session()
    
    def getBulkPricingForItems(self,itemIds):
        try:
            return get_bulk_pricing_for_items(itemIds)
        except:
            return {}
        finally:
            close_session()
    
    def addBulkPricingForItem(self, bulkItemPricing):
        try:
            return to_t_bulk_pricing(add_bulk_pricing_for_item(bulkItemPricing))
        finally:
            close_session()
    
    def getBulkPricingByItemId(self, itemId):
        try:
            bulkPricingItems = get_bulk_pricing_by_item_id(itemId)
            return [to_t_bulk_pricing(bulkPricingItem) for bulkPricingItem in bulkPricingItems]
        finally:
            close_session()
    
    def deleteBulkPricingForItemById(self,id):
        try:
            return delete_bulk_pricing_for_item_by_id(id)
        finally:
            close_session()
            
    def deleteBulkPricingForItem(self,itemId):
        try:
            return delete_bulk_pricing_for_item(itemId)
        except:
            return False
        finally:
            close_session()
    
    def updateBulkPricesOnProduction(self,itemId, bulkItemPricingList):
        try:
            return update_bulk_prices_on_production(itemId, bulkItemPricingList)
        except:
            return False
        finally:
            close_session()
    
    def getCartByValue(self,cartIds):
        try:
            return get_cart_by_value(cartIds)
        finally:
            close_session()
            
    def updateItemPricing(self, itemPricingList):
        try:
            return update_item_pricing(itemPricingList)
        finally:
            close_session()
    
    def bulkUpdateCatalog(self,bulkUploadCatalog):
        try:
            bulk_update_catalog(bulkUploadCatalog)
        finally:
            close_session()
        
     
            
    def getWarrantyInfoForItem(self, catalogItemId, itemCondition):
        try:
            return get_warranty_info_for_item(catalogItemId, itemCondition)
        finally:
            close_session()
            
    def getWarrantyInfoForItemList(self, catalogItemIds, itemCondition):
        try:
            return get_warranty_info_for_item_list(catalogItemIds, itemCondition)
        finally:
            close_session()
            
    def getGstRatesByState(self, stateId):
        try:
            print "getGstRatesByState called"
            return get_gst_rates_by_state(stateId)
        finally:
            close_session()
            
    def getStateTaxRate(self, itemIds, stateId):
        try:
            print "getStateTaxRate called"
            return get_state_tax_rate(itemIds, stateId)
        finally:
            close_session() 
    
    def getIgstTaxRate(self, itemIds):
        try:
            print "getIgstTaxRate called"
            return get_igst_tax_rate(itemIds)
        finally:
            close_session() 
    
    def persistGstRate(self, stateGstRates):
        try:
            print "persistGstRate called"
            add_state_gst_rates(stateGstRates)
        finally:
            close_session() 
            
    def getInterStateGstRates(self,):
        try:
            print "getInterStateGstRates called"
            return get_interstate_gst_rates()
        finally:
            close_session()
            
    def getHsnCodesByCategory(self, categoryId):
        try:
            return get_hsn_codes_by_category(categoryId)
        finally:
            close_session()
            
    def getAllFofoDeals(self, itemIds, tagIds):
        try:
            return get_all_fofo_deals(itemIds, tagIds)
        finally:
            close_session()
        
        
        
    
if __name__ == '__main__':
    c = CatalogServiceHandler()
    bulk_items= c.getBulkPricingForItems([21053,1000])
    for k,y in bulk_items.iteritems():
        print k,
        print '\t',
        print y
            
def is_valid(item):
    if item.status in [status.ACTIVE, status.PAUSED, status.PAUSED_BY_RISK]:
        if item.startDate:
            return not(datetime.datetime.now() < item.startDate or item.sellingPrice == 0)
        else:
            return True
    elif item.status == status.COMING_SOON:
        return True
    else:
        return False