公司资料

宝贝 CC 状态：cc状态是一种被监管的状态.
              是宝贝处于欺诈状态 ..

关联SPU 
        SPU属性值绑定


DefaultSelectCategoryAO getCategories


/**
* 类目查询
* 包括三个参数：sid,path,pv
*
* @author wanjian 2008.12.04
*/
public class ReloadCats extends TemplateScreen {

public void execute(RunData rundata, TemplateContext context)
            throws WebxException {
    rundata.getModuleInfo().setLayout(null);
        ParameterParser params = rundata.getParameters();
       
        for( String key : params.getKeys() ){
        context.put(key, params.get(key));
        }
    }
   
}




/***
* 初始逻辑：
* modified by cyl 2009-04-27
* 对卖家授权品牌进行授权信任,卖家在授权信任的品牌范围内,编辑SPU不受24小时和发布者的限制,但必须是商家确认的
* 1. 卖家必须是b2c卖家并且是spu的发布者,并且状态正常,并且24小时内的
* 2. 卖家品牌授权信任后,只要是授权信任品牌,信任卖家可以编辑其他卖家的SPU,并且没有24小时的限制
* 3. 直充叶子类目下的产品也会有特别的处理，也有个授权卖家的概念   add by zhuliu 2009-11-3
*
*
* modified by baqun 2011-08-30
* 修改逻辑为：
* 1 非标类spu :
* 对卖家授权品牌进行授权信任,卖家在授权信任的品牌范围内,编辑SPU不受24小时和发布者的限制,但必须是商家确认的
* 1. 卖家必须是b2c卖家并且是spu的发布者,并且状态正常,不受24小时的限制
* 2. 卖家品牌授权信任后,只要是授权信任品牌,信任卖家可以编辑其他卖家的SPU,并且没有24小时的限制
* 3. 直充叶子类目下的产品也会有特别的处理，也有个授权卖家的概念
* 2标类：
* 1. 卖家必须是b2c卖家并且是spu的发布者,并且状态正常,在24小时内可以编辑
* 2. 卖家品牌授权信任后,只要是授权信任品牌,信任卖家可以编辑其他卖家的SPU,并且没有24小时的限制
* 3. 直充叶子类目下的产品也会有特别的处理，也有个授权卖家的概念
*  
*/

defaultSpuAo validateCategory


/**
* 验证类目
* @param uidNum
* @param catId
* @param result
*/
private void validateCategory(long uidNum, long catId, SpuResult result) {
StdCategoryDO category = denaliCategoryServices.getCategory(catId);
if (category == null || !category.isLeaf()) {
result.addError(SpuResultCode.OnlyLeafCategoryCanAddSpu);
return;
}
if (!this.isHasKeyProperty(category)) {
result.addError(SpuResultCode.CategoryMustHasKeyProperty);
return;
}

//wanjian 2009.03.02 加类目授权判断
List<Integer> catIds = grantServiceBO.getGrantCategoryList(uidNum);
int rootCat = category.getMainCategory().getCategoryId();
if( CollectionUtil.isNotEmpty(catIds) && !catIds.contains(rootCat) ){
result.addError(SpuResultCode.CategoryNotGranted);
return;
}

List<Integer> brandList = grantServiceBO.getGrantBrandList(uidNum);
if( CollectionUtil.isNotEmpty(brandList) ){
result.setBrandList(brandList);

List<Integer> bidList = new ArrayList<Integer>();
for( int bid : brandList ){
bidList.add(bid);
}

List<GrantBrandValueDO> notInCpvList = new ArrayList<GrantBrandValueDO>();
for( StdCategoryPropertyDO cp : category.getCategoryProperties() ){
if( cp.isBrandProp() ){
for( StdCategoryPropertyValueDO v : cp.getValues() ){
int valueId = v.getValueId();
if( brandList.contains(valueId)){
bidList.remove(Integer.valueOf(valueId));
}
}
}
}

if( bidList.size()>0 ){
//CPV中没有的品牌
for(int valueId : bidList ){
GrantBrandValueDO val = new GrantBrandValueDO();
val.setValueId(valueId);
ValueDO vd = propertyRepoServices.getValueById(valueId);
if( vd == null ) continue;
val.setValue(vd.getValue());

notInCpvList.add(val);
}
}


result.setNotInCpvList(notInCpvList);
}
//add by zhuliu 2009-11-3    如果这个叶子类目对应的品牌已经授权给这个B卖家，在这个做个标记;
boolean isEcardCategory = EcardUtil.isEcardCategory(category);  // 是否直充的叶子类目
boolean hasEcardGranted=ecardAO.hasEcardBrandted(true, uidNum, category.getCategoryId(), isEcardCategory);
result.setEcardGranted(hasEcardGranted); //是否有授权
//end
result.setCategory(category);
}



propMemoMap = categoryMemoManager.getPropertiesMemoByCatId(String
.valueOf(nowCat));
属性描述

spuInfo.vm





一个SPU可以搭配多个SPU（非当前SPU）；一个SPU的替代品可以是多个SPU（非当前SPU）


/**
     * 判断成人类目硬编码去rootcategory的id为2813
     */
    public static boolean isAdultCategory(StdCategoryDO category) {
         if (category != null && category.getMainCategory() != null
             && (2813 == category.getMainCategory().getCategoryId())) {
             return true;
         } else {
             return false;
         }
     }


/**
* 阿坚需求，重新诠释枚举可输入的概念 add by yuanchuo
*
* @param cp
* @param isCSeller
* @return
*/

public static boolean isInputProp(StdCategoryPropertyDO cp, boolean isB2CSeller) {
// TODO 考虑feature的设置
if (cp == null) {
return false;
}

        if (isB2CSeller && cp.isKeyProperty()) {//对B卖家，如果是关键属性，首先校验类目是否只对B关闭了可输入
            FeatureDO feature = new FeatureDO();
            feature.setKey(CategoryFeature.bseller_enum_chk);
            feature.setValue(CategoryFeature.defaultFeatureValue);
     
            if (feature.match(cp.getCategory())) {
                return false;
            } else {
                return true;
            }
        } else {
            return cp.isInputProp();
        }
}



/**
* 防盗链接口，判断描述中的图片和Flash是否存在盗链
* @param descDO  用户防盗链查询参数的封装
* 其中的参数如下：
*desc           描述
*uid;           用户id
*pictureDomain  图片空间域名，默认为taobaocdn.com
*isBuser        是否B卖家,默认为false
*categoryType   需要判断的宝贝或店铺类别,有如下类目：
*               NORMAL-普通类目不做外部域名限制
*               PARTLY_LIMITED-受限制类目，只允许白名单内的域名
*               TAOBAO_ONLY-全部受限类目，例如成人类目，只允许访问淘宝图片空间的图片
*
* @return  AntiStealResult
*     success   true校验正常  false为校验有问题
*     errorEnums 包含检验的错误信息
*                 FLASH_DOMAIN_ERROR                     引用了未授权域名的Flash
*                 FLASH_IS_STEAL                         引用Flash存在盗链
*                 PICTURE_IS_STEAL                       引用Picture存在盗链
*                 UID_CANNOT_LE_ZERO                     UID为空
*                 FLASH_PLAN_UNORDER                     Flash套餐未订购
*                 FLASH_PLAN_FROZEN                      Flash套餐被冻结
*                 FLASH_PLAN_EXPIRED                     Flash套餐到期
*                 PICTURE_PLAN_UNORDER                   图片空间未订购
*                 CANNOT_USE_PICTURE_EXCEP_TAOBAO        对于像成人类目这样只可以使用淘宝域名的类目，不可以使用其他图片服务器的图片
*                 CANNOT_USE_PICTURE_OUT_WHITE_DOMAIN    对于部分受限制类目，不可以使用白名单之外的域名
*/
public AntiStealResult antiStealForDesc(DescDO descDO, List<WhiteListRule> ruleList) {
    //参数初始化
AntiStealResult result = new AntiStealResult();
TextAreaValidateUtil util = new TextAreaValidateUtil();
util.setWhiteList(ruleList);
util.setPictureConfigManager(pictureConfigManager);
String desc = descDO.getDesc();
long uid = descDO.getUid();
if(uid<=0){
result.setSuccess(false);
result.getErrorEnums().add(AntiStealErrorEnum.UID_CANNOT_LE_ZERO);
return result;
}
if(desc==null){
result.setSuccess(true);
return result;
}
String pictureDomain = descDO.getPictureDomain();
if(StringUtil.isBlank(pictureDomain)){
pictureDomain = BaseAntiStealConstants.DEFAULT_PICTURE_DOMAIN;
}
List<String> flashDomains = new ArrayList<String>();
flashDomains.add(ISVEnum.FLASH_123SHOW.getFileDomain());//暂时只有123show一家
boolean buser = descDO.isBuser();
CategoryTypeEnum categoryType = descDO.getCategoryType();
if(categoryType==null){
categoryType = CategoryTypeEnum.NORMAL;
}
/*
* 权限判断
*/
boolean hasFlash = false;
boolean hasPicture = false;
Pattern p = Pattern.compile(BaseAntiStealConstants.MEDIA_REGEX, Pattern.CASE_INSENSITIVE);
Matcher matcher = p.matcher(desc);
if(matcher.find()){
hasFlash = true;
}
List<String> pictures = util.getAllPictureInDesc(desc);
for(String url : pictures){
url = PictureUtil.getDecodedURL(url);
if(!StringUtil.isEmpty(url) ){
String regex = util.getNewGuardRegex(pictureDomain);
Pattern domainPatter = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
Matcher domainMatcher = domainPatter.matcher(url);
if(domainMatcher.find()){
hasPicture = true;
break;
}
}
}
if(hasFlash){
result = checkIsvStatus(uid,ISVEnum.FLASH_123SHOW.getServiceCode());
if (!result.isSuccess()) return result;
}
/*
* 检查描述中图片和Flash是否存在盗链
*/
Set<AntiStealErrorEnum> errors = util.checkFlashAndFileUrl(desc, uid, flashDomains, pictureDomain, categoryType);
if(errors!=null && errors.size()>0){
result.setSuccess(false);
result.setErrorEnums(errors);
result.setErrorMap(util.getErrorMap());
return result;
}else{
result.setSuccess(true);
}
//如果不是盗链的又是图片空间的，那说明是自己的图片，再检查下自己的空间有没有过期
if(hasPicture){
AntiStealErrorEnum order = this.checkPictureAuth(uid,buser);
if(order != AntiStealErrorEnum.PICTURE_VALID){
result.setSuccess(false);
result.getErrorEnums().add(order);
result.setErrorMap(util.getErrorMap());
return result;
}
}
return result;
}












/**
* 处理分销平台商品，保证一些数据不能被修改。
*
* @param item
*            用户修改的，主要商品数据，基本上都在这个对象里。
* @param pio
*            用户修改的，部分商品数据，包括颜色名称等。
* @param la
*            原有的商品数据
*/
private void dealDistributionItem(ItemUpdateDO item, SaveItemOptionDO pio,
LightAuction la) {
item.setAttributeExtra(null); // 食品安全
item.setItemProperties(null); // 宝贝属性
pio.setPropertyAlias(null); // 颜色名称
item.setStuffStatus(la.getStuffStatus()); // 宝贝类型
item.setQuantity(la.getQuantity());// 货存
item.setOuterId(null); // 商家编码
if (la.getHaveInvoice() == 1) { // 发票
item.addOneOption(AuctionConstants.OPTION_HAVE_INVOICE);
} else {
item.removeOneOption(AuctionConstants.OPTION_HAVE_INVOICE);
}
if (la.getHaveGuarantee() == 1) { // 保修
item.addOneOption(AuctionConstants.OPTION_HAVE_GUARANTEE);
} else {
item.removeOneOption(AuctionConstants.OPTION_HAVE_GUARANTEE);
}

// 还原用户输入的文本属性；卖家自己输入的属性内容，比如，衣服的货号属性。
Map<String, String> fs = la.getFeatures();
String input = null;
if (null != fs) {
input = fs.get("prop");
pio.setInputPropertyMap(PropertyUtils
.convertUserInputPropWithAliasMap(PropertyUtils
.feature2forestStructure(input)));
}

// 保证sku除了价格之前的数据不能被修改。
List<ItemSkuDO> newSkuList = item.getSkuList();
List<ItemSkuDO> oldSkuList = la.getSkuList();
if (oldSkuList == null) {
item.setSkuList(null);
} else {
for (ItemSkuDO oldSku : oldSkuList) {
for (ItemSkuDO newSku : newSkuList) {
if (oldSku.getSkuId() == newSku.getSkuId()) {
oldSku.setPrice(newSku.getPrice());
break;
}
}
}
item.setSkuList(oldSkuList);
}
}


private void rememberSelected(TemplateContext context,
boolean rememberSelected,
StatusHoldHelper<String, String> statusHelper,
List<ItemImageDO> itemList, List<StdCategoryPropertyDO> cpList) {
if (rememberSelected) {
// 取级联选择的数据，以便加载时自动显示内容
List<String> pList = new ArrayList<String>();
Map<String, List<String>> multiMap = statusHelper.getMultiValues(
statusHelper, cpList, pList);
context.put("muliJavaScript", StatusHoldHelper
.getStatusHoldJavaScript(pList, multiMap, statusHelper,
propertyRepoServices));

this.holdDataForFail(itemList, statusHelper);

context.put("statusHelper", statusHelper);
}
}




if (stdCat.isLeaf()) {
        //卖霸项目统计叶子类目点击量  add by xiance.gll
log.warn("LeafCat-click" + "catId:"+stdCat.getCategoryId());
            StdCategoryPropertyDO cp = nextCP(fullPid, stdCat, 0);
            if (cp != null) {
                boolean nextKeyCpExist = nextCPExist(fullPid, stdCat, cp.getPropertyId());
                if (!putStdPvs2CgList(cgList, sid, cp, nextKeyCpExist, null, isB2CSeller, uidNum,isBatches)) {
                    return false;
                }
            }
        }