Subversion Repositories SmartDukaan

'''

Created on 23-Mar-2010

@author: ashish

'''

from shop2020.model.v1.catalog.impl.DataService import Insurer, SnapdealItem, Item

from shop2020.thriftpy.model.v1.catalog.ttypes import Item, Category, \

    SourceItemPricing, Source, ItemType, \

    ProductNotificationRequest as TProductNotificationRequest, \

    ProductNotificationRequestCount as TProductNotificationRequestCount, \

    VoucherItemMapping, EntityTag as TEntityTag, Banner as TBanner, BannerMap as TBannerMap, \

    Insurer as TInsurer, BrandInfo as TBrandInfo, Amazonlisted as TAmazonlisted, \

    EbayItem as TEbayItem, BannerUriMapping as TBannerUriMapping, Campaign as TCampaign, \

    SnapdealItem as TSnapdealItem, SnapdealItemDetails as TSnapdealItemDetails,ProductFeedSubmit as TProductFeedSubmit, \

    MarketplaceItems as TMarketplaceItems, MarketplacePercentage as TMarketplacePercentage, \

    MarketPlaceItemPrice as TMarketPlaceItemPrice, FlipkartItem as TFlipkartItem,\

    FlipkartItemDetails as TFlipkartItemDetails,MarketplaceHistory as TMarketplaceHistory,\

    PrivateDeal as TPrivateDeal, AmazonOutOfSync as TAmazonOutOfSync, PdPriceComp as TPdPriceComp, CompetitorPricing as TCompetitorPricing, \

    AmazonPromotion as TAmazonPromotion

from shop2020.utils.Utils import to_java_date

import datetime

def to_t_item(item):

    t_item = Item()

    if item is None:

        return t_item

    t_item.id = item.id

    t_item.productGroup = item.product_group

    t_item.brand = item.brand

    t_item.modelNumber = item.model_number

    t_item.modelName = item.model_name

    t_item.color = item.color

    t_item.category = item.category

    t_item.catalogItemId = item.catalog_item_id

    t_item.weight = item.weight

    t_item.featureId = item.feature_id

    t_item.featureDescription = item.feature_description

    if item.startDate:

        t_item.startDate = to_java_date(item.startDate)

    if item.comingSoonStartDate:

        t_item.comingSoonStartDate = to_java_date(item.comingSoonStartDate)

    if item.expectedArrivalDate:

        t_item.expectedArrivalDate = to_java_date(item.expectedArrivalDate)

    if item.addedOn:

        t_item.addedOn = to_java_date(item.addedOn)

    if item.updatedOn:

        t_item.updatedOn = to_java_date(item.updatedOn)

    t_item.itemStatus = item.status

    t_item.status_description = item.status_description

    if item.sellingPrice:

        t_item.sellingPrice = item.sellingPrice

    if item.mrp:

        t_item.mrp = item.mrp    

    if item.comments:

        t_item.comments = item.comments

    if item.bestDealText:

        t_item.bestDealText = item.bestDealText

    if item.bestDealsDetailsText:

        t_item.bestDealsDetailsText = item.bestDealsDetailsText

    if item.bestDealsDetailsLink:

        t_item.bestDealsDetailsLink = item.bestDealsDetailsLink 

    if item.bestDealValue:

        t_item.bestDealValue = item.bestDealValue

    if item.asin:

        t_item.asin = item.asin    

    t_item.defaultForEntity = item.defaultForEntity

    t_item.bestSellingRank = item.bestSellingRank

    t_item.risky = item.risky

    t_item.expectedDelay = item.expectedDelay

    t_item.isWarehousePreferenceSticky = item.isWarehousePreferenceSticky

    t_item.warrantyPeriod = item.warranty_period

    t_item.preferredVendor = item.preferredVendor

    t_item.type = ItemType._NAMES_TO_VALUES[item.type]

    t_item.hasItemNo = item.hasItemNo

    t_item.activeOnStore = item.activeOnStore

    t_item.showSellingPrice = item.showSellingPrice

    t_item.preferredInsurer = item.preferredInsurer

    t_item.holdInventory = item.holdInventory

    t_item.defaultInventory = item.defaultInventory

    t_item.holdOverride = item.holdOverride

    return t_item

def to_t_insurer(insurer):

    t_insurer = TInsurer()

    t_insurer.id = insurer.id

    t_insurer.name = insurer.name 

    t_insurer.address = insurer.address

    t_insurer.declaredAmount = insurer.declaredAmount

    t_insurer.creditedAmount = insurer.creditedAmount

    return t_insurer

def to_t_voucher_item_mapping(voucher):

    t_voucher = VoucherItemMapping()

    t_voucher.voucherType = voucher.voucherType

    t_voucher.itemId = voucher.item.id

    t_voucher.amount = voucher.amount

    return t_voucher

def to_t_category(category):

    t_category = Category()

    t_category.id = category.id

    t_category.label = category.label

    t_category.description = category.description

    t_category.parent_category_id = category.parent_category_id

    t_category.display_name = category.display_name

    return t_category

def to_t_source_item_pricing(source_item_pricing):

    t_source_item_pricing = SourceItemPricing()

    t_source_item_pricing.sourceId = source_item_pricing.source.id

    t_source_item_pricing.itemId = source_item_pricing.item.id

    t_source_item_pricing.mrp = source_item_pricing.mrp

    t_source_item_pricing.sellingPrice = source_item_pricing.sellingPrice

    return t_source_item_pricing

def to_t_source(source):

    t_source = Source()

    t_source.id = source.id

    t_source.name = source.name

    t_source.identifier = source.identifier

    return t_source

def to_t_product_notification_request(product_notification_request):

    t_product_notification_request = TProductNotificationRequest()

    if product_notification_request:

        t_product_notification_request.item = to_t_item(product_notification_request.item)

        t_product_notification_request.email = product_notification_request.email

        t_product_notification_request.addedOn = to_java_date(product_notification_request.addedOn)

    return t_product_notification_request

def to_t_product_notification_request_count(product_notification_request_count):

    t_product_notification_request_count = TProductNotificationRequestCount()

    if product_notification_request_count:

        item, count = product_notification_request_count

        t_product_notification_request_count.item = to_t_item(item)

        t_product_notification_request_count.count = count

    return t_product_notification_request_count

def to_t_entity_tag(entity_tag):

    t_entity_tag = TEntityTag()

    t_entity_tag.entityId = entity_tag.entityId

    t_entity_tag.tag = entity_tag.tag

def to_t_banner(banner):

    t_banner = TBanner()

    t_banner.bannerName = banner.bannerName

    t_banner.imageName = banner.imageName

    t_banner.link = banner.link

    t_banner.priority = banner.priority

    t_banner.hasMap = banner.hasMap

    t_banner.bannerType = banner.bannerType

    return t_banner

def to_t_banner_list(bannerList):

    t_banner_list = []

    for banner in bannerList:

        t_banner = TBanner()

        t_banner.bannerName = banner.bannerName

        t_banner.imageName = banner.imageName

        t_banner.link = banner.link

        t_banner.priority = banner.priority

        t_banner.hasMap = banner.hasMap

        t_banner.bannerType = banner.bannerType

        t_banner_list.append(t_banner)

    return t_banner_list

def to_t_banner_map(banner_map):

    t_banner_map = TBannerMap()

    t_banner_map.bannerName = banner_map.bannerName

    t_banner_map.mapLink = banner_map.mapLink

    t_banner_map.coordinates = banner_map.coordinates

    return t_banner_map

def to_t_uri_mapping(uriMapping):

    t_uri_mapping =TBannerUriMapping()

    t_uri_mapping.bannerName = uriMapping.bannerName

    t_uri_mapping.uri = uriMapping.uri

    t_uri_mapping.isActive = uriMapping.isActive

    t_uri_mapping.target = uriMapping.target

    return t_uri_mapping

def to_t_campaign(campaign):

    t_campaign = TCampaign()

    t_campaign.id = campaign.id

    t_campaign.campaignName = campaign.campaignName

    t_campaign.imageName = campaign.imageName

    return t_campaign

def to_t_Amazonlisted(Amazonlisted):

    t_amazonlisted = TAmazonlisted()

    if Amazonlisted is None:

        return t_amazonlisted

    t_amazonlisted.asin = Amazonlisted.asin

    t_amazonlisted.brand = Amazonlisted.brand 

    t_amazonlisted.itemid = Amazonlisted.itemId

    t_amazonlisted.model = Amazonlisted.model

    t_amazonlisted.manufacturer_name = Amazonlisted.manufacturer_name

    t_amazonlisted.upc = Amazonlisted.upc

    t_amazonlisted.part_number = Amazonlisted.part_number

    t_amazonlisted.name = Amazonlisted.name

    t_amazonlisted.ean = Amazonlisted.ean

    t_amazonlisted.fbaPrice = Amazonlisted.fbaPrice

    t_amazonlisted.fbbPrice = Amazonlisted.fbbPrice

    t_amazonlisted.sellingPrice = Amazonlisted.sellingPrice

    t_amazonlisted.isFba = Amazonlisted.isFba

    t_amazonlisted.isFbb = Amazonlisted.isFbb

    t_amazonlisted.isNonFba = Amazonlisted.isNonFba

    t_amazonlisted.isInventoryOverride = Amazonlisted.isInventoryOverride

    t_amazonlisted.color = Amazonlisted.color

    t_amazonlisted.category = Amazonlisted.category

    t_amazonlisted.handlingTime = Amazonlisted.handlingTime

    t_amazonlisted.isCustomTime = Amazonlisted.isCustomTime

    t_amazonlisted.category_code = Amazonlisted.category_code

    t_amazonlisted.mfnPriceLastUpdatedOn = to_java_date(Amazonlisted.mfnPriceLastUpdatedOn)

    t_amazonlisted.fbaPriceLastUpdatedOn = to_java_date(Amazonlisted.fbaPriceLastUpdatedOn)

    t_amazonlisted.fbbPriceLastUpdatedOn = to_java_date(Amazonlisted.fbbPriceLastUpdatedOn)

    t_amazonlisted.mfnPriceLastUpdatedOnSc = to_java_date(Amazonlisted.mfnPriceLastUpdatedOnSc)

    t_amazonlisted.fbbPriceLastUpdatedOnSc = to_java_date(Amazonlisted.fbbPriceLastUpdatedOnSc)

    t_amazonlisted.fbaPriceLastUpdatedOnSc = to_java_date(Amazonlisted.fbaPriceLastUpdatedOnSc)

    t_amazonlisted.suppressMfnPriceUpdate = Amazonlisted.suppressMfnPriceUpdate

    t_amazonlisted.suppressFbaPriceUpdate = Amazonlisted.suppressFbaPriceUpdate

    t_amazonlisted.suppressFbbPriceUpdate = Amazonlisted.suppressFbbPriceUpdate

    t_amazonlisted.taxCode = Amazonlisted.taxCode

    t_amazonlisted.fbbtaxCode = Amazonlisted.fbbtaxCode

    t_amazonlisted.overrrideWanlc = Amazonlisted.overrrideWanlc

    t_amazonlisted.exceptionalWanlc = Amazonlisted.exceptionalWanlc

    t_amazonlisted.autoDecrement = Amazonlisted.autoDecrement

    t_amazonlisted.autoIncrement = Amazonlisted.autoIncrement

    t_amazonlisted.autoFavourite = Amazonlisted.autoFavourite

    t_amazonlisted.manualFavourite = Amazonlisted.manualFavourite

    return t_amazonlisted

def to_t_ebay_item(ebay_item):

    t_ebay_item = TEbayItem()

    t_ebay_item.ebayListingId = ebay_item.ebayListingId

    t_ebay_item.itemId = ebay_item.itemId

    t_ebay_item.listingName = ebay_item.listingName

    t_ebay_item.listingPrice = ebay_item.listingPrice

    t_ebay_item.listingExpiryDate = to_java_date(ebay_item.listingExpiryDate)

    t_ebay_item.subsidy = ebay_item.subsidy

    return t_ebay_item

def to_t_brand_info(brand_info):

    t_brand_info = TBrandInfo()

    t_brand_info.name = brand_info.name

    t_brand_info.serviceCenterLocatorUrl = brand_info.serviceCenterLocatorUrl

    return t_brand_info

def to_t_snapdeal_item(snapdealitem):

    if snapdealitem is None:

        t_snapdeal_item = TSnapdealItem()

        return t_snapdeal_item

    t_snapdeal_item = TSnapdealItem()

    t_snapdeal_item.item_id = snapdealitem[0].item_id

    t_snapdeal_item.warehouseId = snapdealitem[0].warehouseId

    t_snapdeal_item.exceptionPrice = snapdealitem[0].exceptionPrice

    t_snapdeal_item.transferPrice = snapdealitem[0].transferPrice

    t_snapdeal_item.sellingPrice = snapdealitem[0].sellingPrice

    t_snapdeal_item.courierCost = snapdealitem[0].courierCost

    t_snapdeal_item.courierCostMarketplace = snapdealitem[0].courierCostMarketplace

    t_snapdeal_item.commission = snapdealitem[0].commission

    t_snapdeal_item.serviceTax = snapdealitem[0].serviceTax

    t_snapdeal_item.isListedOnSnapdeal = snapdealitem[0].isListedOnSnapdeal

    t_snapdeal_item.suppressPriceFeed = snapdealitem[0].suppressPriceFeed

    t_snapdeal_item.suppressInventoryFeed = snapdealitem[0].suppressInventoryFeed

    t_snapdeal_item.maxNlc = snapdealitem[0].maxNlc

    t_snapdeal_item.skuAtSnapdeal = snapdealitem[0].skuAtSnapdeal

    t_snapdeal_item.supc = snapdealitem[0].supc

    t_snapdeal_item.shippingTime = snapdealitem[0].shippingTime

    return t_snapdeal_item

def to_t_snapdeal_item_details(snapdealitem,snapdealItemInventory):

    if snapdealitem is None:

        t_snapdeal_item_details = TSnapdealItemDetails()

        return t_snapdeal_item_details

    t_snapdeal_item_details = TSnapdealItemDetails()

    t_snapdeal_item_details.item_id = snapdealitem[0].item_id

    t_snapdeal_item_details.warehouseId = snapdealitem[0].warehouseId

    t_snapdeal_item_details.exceptionPrice = snapdealitem[0].exceptionPrice

    t_snapdeal_item_details.transferPrice = snapdealitem[0].transferPrice

    t_snapdeal_item_details.sellingPrice = snapdealitem[0].sellingPrice

    t_snapdeal_item_details.courierCost = snapdealitem[0].courierCost

    t_snapdeal_item_details.courierCostMarketplace = snapdealitem[0].courierCostMarketplace

    t_snapdeal_item_details.commission = snapdealitem[0].commission

    t_snapdeal_item_details.serviceTax = snapdealitem[0].serviceTax

    t_snapdeal_item_details.brand = snapdealitem[1].brand

    t_snapdeal_item_details.model_name = snapdealitem[1].model_name

    t_snapdeal_item_details.model_number = snapdealitem[1].model_number

    t_snapdeal_item_details.color = snapdealitem[1].color

    t_snapdeal_item_details.risky = snapdealitem[1].risky

    t_snapdeal_item_details.itemStatus = snapdealitem[1].status

    t_snapdeal_item_details.isListedOnSnapdeal = snapdealitem[0].isListedOnSnapdeal

    t_snapdeal_item_details.weight = snapdealitem[1].weight

    t_snapdeal_item_details.mrp = snapdealitem[1].mrp

    t_snapdeal_item_details.websiteSellingPrice = snapdealitem[1].sellingPrice

    t_snapdeal_item_details.suppressPriceFeed = snapdealitem[0].suppressPriceFeed

    t_snapdeal_item_details.suppressInventoryFeed = snapdealitem[0].suppressInventoryFeed

    t_snapdeal_item_details.maxNlc = snapdealitem[0].maxNlc

    t_snapdeal_item_details.skuAtSnapdeal = snapdealitem[0].skuAtSnapdeal

    t_snapdeal_item_details.supc = snapdealitem[0].supc

    t_snapdeal_item_details.shippingTime = snapdealitem[0].shippingTime

    if snapdealItemInventory is not None:

        t_snapdeal_item_details.lastUpdatedInventory = snapdealItemInventory.availability

        t_snapdeal_item_details.lastUpdatedInventoryTimestamp = snapdealItemInventory.lastUpdatedOnSnapdeal 

    return t_snapdeal_item_details

def to_t_product_feed_submit(productfeedsubmit):

    if productfeedsubmit is None:

        t_product_feed_submit = TProductFeedSubmit()

        return t_product_feed_submit

    t_product_feed_submit = TProductFeedSubmit()

    t_product_feed_submit.catalogItemId = productfeedsubmit.catalogItemId

    t_product_feed_submit.stockLinkedFeed = productfeedsubmit.stockLinkedFeed

    return t_product_feed_submit

def to_t_marketplace_items(marketplaceItem):

    t_marketplace_item = TMarketplaceItems() 

    if marketplaceItem is None:

        return t_marketplace_item

    t_marketplace_item.itemId = marketplaceItem.itemId

    t_marketplace_item.source = marketplaceItem.source

    t_marketplace_item.emiFee = marketplaceItem.emiFee

    t_marketplace_item.courierCost = marketplaceItem.courierCost

    t_marketplace_item.courierCostMarketplace = marketplaceItem.courierCostMarketplace

    t_marketplace_item.closingFee = marketplaceItem.closingFee

    t_marketplace_item.commission = marketplaceItem.commission

    t_marketplace_item.returnProvision = marketplaceItem.returnProvision

    t_marketplace_item.vat = marketplaceItem.vat

    t_marketplace_item.packagingCost = marketplaceItem.packagingCost

    t_marketplace_item.otherCost = marketplaceItem.otherCost

    t_marketplace_item.serviceTax = marketplaceItem.serviceTax

    t_marketplace_item.autoIncrement = marketplaceItem.autoIncrement

    t_marketplace_item.autoDecrement = marketplaceItem.autoDecrement

    t_marketplace_item.autoFavourite = marketplaceItem.autoFavourite

    t_marketplace_item.manualFavourite = marketplaceItem.manualFavourite

    t_marketplace_item.currentSp = marketplaceItem.currentSp

    t_marketplace_item.currentTp = marketplaceItem.currentTp

    t_marketplace_item.minimumPossibleSp = marketplaceItem.minimumPossibleSp

    t_marketplace_item.minimumPossibleTp = marketplaceItem.minimumPossibleTp

    t_marketplace_item.lastCheckedTimestamp = to_java_date(marketplaceItem.lastCheckedTimestamp)

    t_marketplace_item.maximumSellingPrice = marketplaceItem.maximumSellingPrice

    t_marketplace_item.pgFee = marketplaceItem.pgFee

    return t_marketplace_item

def to_t_marketplace_itemprice(marketplaceitemprice):

    t_marketplace_priceitem = TMarketPlaceItemPrice()    

    t_marketplace_priceitem.item_id = marketplaceitemprice.item_id

    t_marketplace_priceitem.source = marketplaceitemprice.source

    t_marketplace_priceitem.sellingPrice = marketplaceitemprice.sellingPrice

    t_marketplace_priceitem.lastUpdatedOn = to_java_date(marketplaceitemprice.lastUpdatedOn)

    t_marketplace_priceitem.lastUpdatedOnMarketplace = to_java_date(marketplaceitemprice.lastUpdatedOnMarketplace)

    t_marketplace_priceitem.isPriceOverride = marketplaceitemprice.suppressPriceFeed

    t_marketplace_priceitem.isListedOnSource = marketplaceitemprice.isListedOnSource

    return t_marketplace_priceitem 

def to_t_marketplacepercentage(marketplacePercentage):

    t_marketplacepercentage = TMarketplacePercentage()

    if marketplacePercentage is None:

        return t_marketplacepercentage

    t_marketplacepercentage.source =  marketplacePercentage.source

    t_marketplacepercentage.emiFee =  marketplacePercentage.emiFee

    t_marketplacepercentage.closingFee = marketplacePercentage.closingFee

    t_marketplacepercentage.returnProvision = marketplacePercentage.returnProvision

    t_marketplacepercentage.commission = marketplacePercentage.commission

    t_marketplacepercentage.serviceTax = marketplacePercentage.serviceTax

    t_marketplacepercentage.pgFee = marketplacePercentage.pgFee

    return t_marketplacepercentage

def to_t_flipkart_item(flipkartItem):

    t_flipkartitem = TFlipkartItem()

    if flipkartItem is None:

        return t_flipkartitem

    t_flipkartitem.item_id = flipkartItem[0].item_id  

    t_flipkartitem.exceptionPrice = flipkartItem[0].exceptionPrice

    t_flipkartitem.warehouseId = flipkartItem[0].warehouseId

    t_flipkartitem.commissionValue  =  flipkartItem[0].commissionValue

    t_flipkartitem.serviceTaxValue  =  flipkartItem[0].serviceTaxValue

    t_flipkartitem.maxNlc = flipkartItem[0].maxNlc

    t_flipkartitem.skuAtFlipkart = flipkartItem[0].skuAtFlipkart

    t_flipkartitem.isListedOnFlipkart = flipkartItem[0].isListedOnFlipkart

    t_flipkartitem.suppressPriceFeed = flipkartItem[0].suppressPriceFeed

    t_flipkartitem.suppressInventoryFeed = flipkartItem[0].suppressInventoryFeed

    #t_flipkartitem.updatedOn = to_java_date(flipkartItem.updatedOn)

    t_flipkartitem.updatedBy = flipkartItem[0].updatedBy

    t_flipkartitem.flipkartSerialNumber = flipkartItem[0].flipkartSerialNumber

    return t_flipkartitem

def to_t_flipkart_item_details(flipkartitem,flipkartItemInventory):

    if flipkartitem is None:

        t_flipkart_item_details = TFlipkartItemDetails()

        return t_flipkart_item_details

    t_flipkart_item_details = TFlipkartItemDetails()

    t_flipkart_item_details.item_id = flipkartitem[0].item_id

    t_flipkart_item_details.warehouseId = flipkartitem[0].warehouseId

    t_flipkart_item_details.exceptionPrice = flipkartitem[0].exceptionPrice

    t_flipkart_item_details.commission = flipkartitem[0].commissionValue

    t_flipkart_item_details.serviceTax = flipkartitem[0].serviceTaxValue

    t_flipkart_item_details.brand = flipkartitem[1].brand

    t_flipkart_item_details.model_name = flipkartitem[1].model_name

    t_flipkart_item_details.model_number = flipkartitem[1].model_number

    t_flipkart_item_details.color = flipkartitem[1].color

    t_flipkart_item_details.risky = flipkartitem[1].risky

    t_flipkart_item_details.itemStatus = flipkartitem[1].status

    t_flipkart_item_details.isListedOnFlipkart = flipkartitem[0].isListedOnFlipkart

    t_flipkart_item_details.weight = flipkartitem[1].weight

    t_flipkart_item_details.mrp = flipkartitem[1].mrp

    t_flipkart_item_details.websiteSellingPrice = flipkartitem[1].sellingPrice

    t_flipkart_item_details.suppressPriceFeed = flipkartitem[0].suppressPriceFeed

    t_flipkart_item_details.suppressInventoryFeed = flipkartitem[0].suppressInventoryFeed

    t_flipkart_item_details.maxNlc = flipkartitem[0].maxNlc

    t_flipkart_item_details.skuAtFlipkart = flipkartitem[0].skuAtFlipkart

    t_flipkart_item_details.flipkartSerialNumber = flipkartitem[0].flipkartSerialNumber

    t_flipkart_item_details.category = flipkartitem[1].category

    if flipkartItemInventory is not None:

        t_flipkart_item_details.lastUpdatedInventory = flipkartItemInventory.availability

        #t_flipkart_item_details.lastUpdatedInventoryTimestamp = flipkartItemInventory.lastUpdatedOnFlipkart 

    return t_flipkart_item_details

def to_t_market_place_history(marketplaceHistory):

    t_marketplace_history = TMarketplaceHistory()

    if marketplaceHistory is None:

        return t_marketplace_history

    t_marketplace_history.item_id = marketplaceHistory.item_id

    t_marketplace_history.source = marketplaceHistory.source

    t_marketplace_history.timestamp = to_java_date(marketplaceHistory.timestamp)

    if marketplaceHistory.lowestPossibleTp is None:

        t_marketplace_history.lowest_possible_tp =0

    else:

        t_marketplace_history.lowest_possible_tp = int(marketplaceHistory.lowestPossibleTp)

    if marketplaceHistory.lowestPossibleSp is None:

        t_marketplace_history.lowest_possible_sp = 0

    else:

        t_marketplace_history.lowest_possible_sp = int(marketplaceHistory.lowestPossibleSp)

    t_marketplace_history.ourInventory = marketplaceHistory.ourInventory

    t_marketplace_history.otherInventory = marketplaceHistory.otherInventory

    t_marketplace_history.secondLowestInventory = marketplaceHistory.secondLowestInventory

    t_marketplace_history.ourRank = marketplaceHistory.ourRank

    if marketplaceHistory.ourOfferPrice is None:

        t_marketplace_history.ourOfferPrice = 0

    else: 

        t_marketplace_history.ourOfferPrice = int(marketplaceHistory.ourOfferPrice)

    if marketplaceHistory.ourSellingPrice is None:

        t_marketplace_history.ourSellingPrice = 0

    else:

        t_marketplace_history.ourSellingPrice = int(marketplaceHistory.ourSellingPrice)

    if marketplaceHistory.ourTp is None:

        t_marketplace_history.ourTp = 0

    else:

        t_marketplace_history.ourTp = int(marketplaceHistory.ourTp)

    if marketplaceHistory.ourNlc is None:

        t_marketplace_history.ourNlc = 0

    else:

        t_marketplace_history.ourNlc = int(marketplaceHistory.ourNlc)

    t_marketplace_history.competitiveCategory = marketplaceHistory.competitiveCategory

    t_marketplace_history.risky = marketplaceHistory.risky

    if marketplaceHistory.lowestOfferPrice is None:

        t_marketplace_history.lowestOfferPrice = 0

    else:

        t_marketplace_history.lowestOfferPrice = int(marketplaceHistory.lowestOfferPrice)

    if marketplaceHistory.lowestSellingPrice is None:

        t_marketplace_history.lowestSellingPrice = 0

    else:

        t_marketplace_history.lowestSellingPrice = int(marketplaceHistory.lowestSellingPrice)

    if marketplaceHistory.lowestTp is None:

        t_marketplace_history.lowestTp = 0

    else:

        t_marketplace_history.lowestTp = int(marketplaceHistory.lowestTp)

    if marketplaceHistory.lowestSellerName is None:

        t_marketplace_history.lowestSellerName = ''

    else:

        t_marketplace_history.lowestSellerName = marketplaceHistory.lowestSellerName

    if marketplaceHistory.proposedSellingPrice is None:

        t_marketplace_history.proposedSellingPrice = 0

    else:

        t_marketplace_history.proposedSellingPrice = int(marketplaceHistory.proposedSellingPrice)

    if marketplaceHistory.proposedTp is None:

        t_marketplace_history.proposedTp = 0

    else:

        t_marketplace_history.proposedTp = int(marketplaceHistory.proposedTp)

    if marketplaceHistory.targetNlc is None:

        t_marketplace_history.targetNlc = 0

    else:

        t_marketplace_history.targetNlc = int(marketplaceHistory.targetNlc)

    t_marketplace_history.salesPotential = marketplaceHistory.salesPotential

    if marketplaceHistory.secondLowestSellerName is None:

        t_marketplace_history.secondLowestSellerName = ''

    else:

        t_marketplace_history.secondLowestSellerName = marketplaceHistory.secondLowestSellerName

    if marketplaceHistory.secondLowestSellingPrice is None:

        t_marketplace_history.secondLowestSellingPrice=0

    else:

        t_marketplace_history.secondLowestSellingPrice = int(marketplaceHistory.secondLowestSellingPrice)

    if marketplaceHistory.secondLowestOfferPrice is None:

        t_marketplace_history.secondLowestOfferPrice = 0

    else:

        t_marketplace_history.secondLowestOfferPrice = int(marketplaceHistory.secondLowestOfferPrice)

    if marketplaceHistory.secondLowestTp is None:

        t_marketplace_history.secondLowestTp=0

    else:

        t_marketplace_history.secondLowestTp = int(marketplaceHistory.secondLowestTp)

    t_marketplace_history.marginIncreasedPotential = marketplaceHistory.marginIncreasedPotential

    if marketplaceHistory.margin is None:

        t_marketplace_history.margin = 0

    else:

        t_marketplace_history.margin = int(marketplaceHistory.margin)

    t_marketplace_history.ourEnoughStock = marketplaceHistory.ourEnoughStock

    t_marketplace_history.totalSeller = marketplaceHistory.totalSeller

    t_marketplace_history.averageSale = marketplaceHistory.avgSales

    t_marketplace_history.toGroup = marketplaceHistory.toGroup

    t_marketplace_history.decision = marketplaceHistory.decision

    t_marketplace_history.reason = marketplaceHistory.reason

    return t_marketplace_history

def to_t_private_deal(private_deal_item):

    if private_deal_item is None:

        t_private_deal_item = TPrivateDeal()

        return t_private_deal_item

    t_private_deal_item = TPrivateDeal()

    t_private_deal_item.item_id = private_deal_item.item_id

    t_private_deal_item.dealPrice = private_deal_item.dealPrice

    t_private_deal_item.dealFreebieItemId = private_deal_item.dealFreebieItemId

    t_private_deal_item.startDate = to_java_date(private_deal_item.startDate)

    t_private_deal_item.endDate = to_java_date(private_deal_item.endDate)

    t_private_deal_item.dealTextOption = private_deal_item.dealTextOption

    if private_deal_item.dealText is None: 

        t_private_deal_item.dealText = ''

    else:

        t_private_deal_item.dealText = private_deal_item.dealText    

    t_private_deal_item.isCod = private_deal_item.isCod

    t_private_deal_item.rank = private_deal_item.rank

    t_private_deal_item.dealFreebieOption = private_deal_item.dealFreebieOption

    t_private_deal_item.isActive = private_deal_item.isActive

    return t_private_deal_item

def to_t_amazonoutofsync(amazonOutOfSync):

    t_amazonoutofsync = TAmazonOutOfSync()

    if amazonOutOfSync is None:

        return t_amazonoutofsync

    else:

        t_amazonoutofsync.item_id = amazonOutOfSync.item_id

        t_amazonoutofsync.mfn = amazonOutOfSync.mfn

        t_amazonoutofsync.fba = amazonOutOfSync.fba

        t_amazonoutofsync.fbb = amazonOutOfSync.fbb

        return t_amazonoutofsync

def to_t_private_deals_comparison(item):

    xstr = lambda s: s or ""

    t_pdcomp = TPdPriceComp()

    pdComp = item[0]

    catItem  = item[1]

    t_pdcomp.item_id = pdComp.item_id

    t_pdcomp.dealPrice = pdComp.dealPrice

    t_pdcomp.saholicPrice = pdComp.saholicPrice

    t_pdcomp.sdPrice = pdComp.sdPrice

    t_pdcomp.fkPrice = pdComp.fkPrice

    t_pdcomp.amazonPrice = pdComp.amazonPrice

    t_pdcomp.productName = xstr(catItem.brand)+" "+xstr(catItem.model_name)+" "+xstr(catItem.model_number)+" "+xstr(catItem.color)

    t_pdcomp.lastProcessedTimestamp = to_java_date(pdComp.lastProcessedTimestamp)

    return t_pdcomp

def to_t_snapdeal_marketplace_item(item):

    mpItem = item[1]

    dItem = item[2]

    t_sd_item = to_t_snapdeal_item(item)

    t_sd_item.marketplaceItems = to_t_marketplace_items(mpItem)

    t_sd_item.item = to_t_item(dItem)

    return t_sd_item

def to_t_flipkart_marketplace_item(item):

    mpItem = item[1]

    dItem = item[2]

    t_fk_item = to_t_flipkart_item(item)

    t_fk_item.marketplaceItems = to_t_marketplace_items(mpItem)

    t_fk_item.item = to_t_item(dItem)

    return t_fk_item

def to_t_competitor_pricing(compPricing):

    xstr = lambda s: s or ""

    item = compPricing[0]

    catItem = compPricing[1]

    t_comp = TCompetitorPricing()

    t_comp.productName = xstr(catItem.brand)+" "+xstr(catItem.model_name)+" "+xstr(catItem.model_number)+" "+xstr(catItem.color)

    t_comp.item_id = item.item_id

    t_comp.lowestSnapdealPrice = item.lowestSnapdealPrice

    t_comp.lowestFlipkartPrice = item.lowestFlipkartPrice

    t_comp.lowestAmazonPrice = item.lowestAmazonPrice

    t_comp.ourSnapdealPrice = item.ourSnapdealPrice

    t_comp.ourSnapdealOfferPrice = item.ourSnapdealOfferPrice

    t_comp.ourSnapdealInventory = item.ourSnapdealInventory

    t_comp.lowestSnapdealOfferPrice = item.lowestSnapdealOfferPrice

    if item.lowestSnapdealSeller is None:

        t_comp.lowestSnapdealSeller=''

    else:

        t_comp.lowestSnapdealSeller = item.lowestSnapdealSeller

    t_comp.lowestSnapdealSellerInventory = item.lowestSnapdealSellerInventory

    t_comp.ourFlipkartPrice = item.ourFlipkartPrice

    t_comp.ourFlipkartInventory = item.ourFlipkartInventory

    if item.lowestFlipkartSeller is None:

        t_comp.lowestFlipkartSeller=''

    else:

        t_comp.lowestFlipkartSeller = item.lowestFlipkartSeller

    t_comp.ourMfnPrice = item.ourMfnPrice

    t_comp.ourFbaPrice = item.ourFbaPrice

    t_comp.ourMfnInventory = item.ourMfnInventory

    t_comp.ourFbaInventory = item.ourFbaInventory

    t_comp.lowestAmazonPrice = item.lowestAmazonPrice

    if item.lowestAmazonSeller is None:

        t_comp.lowestAmazonSeller=''

    else:

        t_comp.lowestAmazonSeller = item.lowestAmazonSeller

    return t_comp

def to_t_amazon_promotion(amazonPromotion):

    t_amazonPromotion = TAmazonPromotion()

    t_amazonPromotion.sku = amazonPromotion.sku

    t_amazonPromotion.startDate = to_java_date(datetime.datetime.combine(amazonPromotion.startDate, datetime.datetime.min.time()))

    t_amazonPromotion.endDate = to_java_date(datetime.datetime.combine(amazonPromotion.endDate, datetime.datetime.min.time()))

    t_amazonPromotion.updatedOnMarketplace = to_java_date(amazonPromotion.updatedOnMarketplace)

    t_amazonPromotion.promotionActive = amazonPromotion.promotionActive

    t_amazonPromotion.addedOn = to_java_date(amazonPromotion.addedOn)

    t_amazonPromotion.standardPrice = amazonPromotion.standardPrice

    t_amazonPromotion.salePrice = amazonPromotion.salePrice

    t_amazonPromotion.stateId = amazonPromotion.stateId

    t_amazonPromotion.promotionType = amazonPromotion.promotionType

    return t_amazonPromotion

def to_t_Amazonlisted_promo(amazonDetails):

    amazonlisted = amazonDetails[0]

    fbaPromo = amazonDetails[1]

    fbbPromo = amazonDetails[2]

    t_amazon = to_t_Amazonlisted(amazonlisted)

    if not (fbaPromo is None or len(fbaPromo)==0):

        t_amazon.fbaSalePrice = fbaPromo[0].salePrice

    if not (fbbPromo is None or len(fbbPromo)==0):

        t_amazon.fbbSalePrice = fbbPromo[0].salePrice

    return t_amazon