import ApiBase from './api_base'
import ApiEnum from './api_enum'
import Server from './server'

let api = Object.assign({}, ApiBase);



api.checkUserIsNew=(data={})=>{
	return api.requestWithTicket(ApiEnum.checkUserIsNew,data,'POST')
}

/**
 * 游客登录
 * @param {string} account 账号
 * @param {string} passwd	密码
 * 
 * @return {string} accid	IM 账号
 * @return {string} token	IM TOKEN
 * @return {string} sessionId	session
 * @return {string} userId 用户ID
 */
api.touristLogin = (data = {}) => {
	if(data.account==null&&data.passwd==null){
		data.account = Server.account
		data.passwd = Server.passwd
	}
  
  return api.requestWithTicket(ApiEnum.touristLogin, data, 'POST');
}

// 先调0010117接口获取返回参数后，再调用0010116就可以登录并返回用户信息
/**
 * 小程序登录
 * @param {string} code	条码值
 * 
 * @return {string} expiresIn
 * @return {string} sessionKey
 * @return {string} expiresTill
 * @return {string} openId
 * @return {string} class
 */
api.loginByCode = (data) => {
  return api.requestWithTicket(ApiEnum.loginByCode, data, 'POST');
}

/**
 * 小程序登录后密文解密
 * @param {string} openId	
 * @param {string} sessionKey	加密签名的密钥
 * @param {string} encryptedData 用户信息的加密数据
 * @param {string} iv 初始向量
 * 
 * @return {int} businessId 商家ID
 * @return {string} accid	IM 账号
 * @return {string} token	IM TOKEN
 * @return {string} sessionId	session
 * @return {string} userId 用户ID
 */
api.loginByWxapp = (data) => {
	let reqParam = wx.getStorageSync('reqParam');
	if(reqParam.type == "jym" && reqParam.param != null){
		data.presenter = reqParam.param;
	}
	console.error("loginByWxapp", JSON.stringify(data));
  return api.requestWithTicket(ApiEnum.loginByWxapp, data, 'POST');
}

/**
 * 更新用户头像
 * @param {int} userId 用户ID
 * @param {string} avatar 用户头像
 */
api.updateIcon = (data) => {
  return api.requestWithTicket(ApiEnum.updateIcon, data, 'POST');
}

/**
 * BC端获取个人信息
 * @return {string} phone 电话
 * @return {string} username 用户名 
 * @return {int} gender 性别 
 * @return {string} icon 图标 
 * @return {date} birth 生日 
 * @return {string} idCard 身份证号码 
 * @return {string} name 会员名称
 */
api.BCmy = (data) => {
  return api.requestWithTicket(ApiEnum.BCmy, data, 'POST');
}

/**
 * BC端编辑个人信息
 * @param {string} phone 电话
 * @param {string} username 用户名 
 * @param {int} gender 性别 
 * @param {string} icon 图标 
 * @param {date} birth 生日 
 * @param {string} idCard 身份证号码 
 * @param {string} name 会员名称
 */
api.BCedit = (data) => {
  return api.requestWithTicket(ApiEnum.BCedit, data, 'POST');
}

/**
 * 获取我的界面基本数据
 * @param {int} memberId 用户ID
 *
 * @return {string} serviceTel 电话
 * @return {int} supplierNum 供应商数量
 * @return {int} browseNum 浏览数量
 * @return {int} favoriteNum 收藏数量
 * @return {int} inviteNum 邀约数量
 * @return {Object} user 用户信息
 *    @return {string} avatar 头像
 *    @return {int} id 主键
 *    @return {string} username 用户名
 *    @return {string} mobile 手机号码
 *    @return {string} address 地址
 * @return {Object} orderStatusNum 订单状态数量
 *    @return {int} pendingPayment 待付款数量
 *    @return {int} pendingShipment 待发货
 *    @return {int} shipped 待收货数量
 *    @return {int} pendingReview 待评论
 *    @return {int} afterSale 售后数量
 * @return {Object} verifiedStatus 认证状态
 *    @return {int} unUrlCount 没有文件路径的个数
 *    @return {int} verified 认证状态 {UN:没有; WAIT:待认证; FAIL:失败; PASS:通过;}
 *    @return {bool} isExpire 是否过期
 *    @return {int} accstatus	账户状态
 *    @return {string} address	地址
 */
api.getMyBaseDatas = (data) => {
  return api.requestWithTicket(ApiEnum.getMyBaseDatas, data, 'POST');
}

/**
 * 注册协议
 */
api.getAppRegisterAgreement = (data) => {
  return api.requestWithTicket(ApiEnum.getAppRegisterAgreement, data, 'GET');
}
/**
 * 获取公司介绍
 */
api.lookIntroduction = (data) => {
  return api.requestWithTicket(ApiEnum.lookIntroduction, data, 'GET');
}

/**
 * 商家动态
 * @param {int} pageNo 页数（从第0页开始，默认第0页）
 * @param {int} pageSize 每面数据条数（默认10条）
 * @param {int} storeId 店铺Id
 */
api.getStoreDynamic = (data) => {
  return api.requestWithTicket(ApiEnum.getStoreDynamic, data, 'GET');
}

/**
 * 店铺首页 广告、导航菜单、公司信息
 * @param {int} storeId 商铺ID
 */
api.storeHomeNavAds = (data) => {
  return api.requestWithTicket(ApiEnum.storeHomeNavAds, data, 'GET');
}

/**
 * 店铺首页产品
 * @param {int} storeId 商铺ID
 */
api.homeNavAds = (data) => {
  return api.requestWithTicket(ApiEnum.homeNavAds, data, 'GET');
}

/**
 * 店铺首页产品
 * @param {int} storeId 商铺ID
 */
api.storeHomeProducts = (data) => {
  return api.requestWithTicket(ApiEnum.storeHomeProducts, data, 'POST');
}
/**
 * 店铺产品标签列表
 * @param {int} storeId 商铺ID
 */
api.storeHomeProductTags = (data) => {
  return api.requestWithTicket(ApiEnum.storeHomeProductTags, data, 'GET');
}

//店铺首页 导航标签组
api.storeHomeNavTags = (data) => {
  return api.requestWithTicket(ApiEnum.storeHomeNavTags, data, 'GET');
}

/**
 * 查找店铺商品分类
 * @param {int} storeId 商铺ID
 */
api.getStoreProductCategorys = (data) => {
  return api.requestWithTicket(ApiEnum.getStoreProductCategorys, data, 'GET');
}

/**
 * 获取查询产品筛选条件
 * @param {int} productCategoryId 商品分类ID
 */
api.getSearchProductFilter = (data) => {
  return api.requestWithTicket(ApiEnum.getSearchProductFilter, data, 'GET');
}

/**
 * 获取商品分类
 * @param {int} storeId 传入店铺ID
 */
api.getProductCategorys = (data) => {
  return api.requestWithTicket(ApiEnum.getProductCategorys, data, 'POST');
}

/**
 * 通过id查询商品子分类
 * @param {int} id 主键子分类
 */
api.getProductChildrenCategorys = (data) => {
  return api.requestWithTicket(ApiEnum.getProductChildrenCategorys, data, 'GET');
}

/**
 * 分类广告
 */
api.getProductCategorysAd = (data) => {
  return api.requestWithTicket(ApiEnum.getProductCategorysAd, data, 'POST');
}
/**
 * 获取商品详情
 * @param {int} memberId  用户Id
 * @param {int} productId 产品ID
 * 
 * @return {string} info 药品详情
 * @return {Array} introduction 药品说明书
 *    @return {string} group 分组名称
 *    @return {Array} entries 产品条目
 *       @return {string} name 名字
 *       @return {string} value 值
 *       @return {int} pendingReview 待评论	
 *       @return {int} afterSale 售后数量
 *       @return {int} pendingShipment 待发货	
 *    @return {int} pendingReview 待评论
 *    @return {int} afterSale 售后数量
 *    @return {int} pendingShipment 待发货
 * @return {Object} base 商品基本信息
 *    @return {Array} productImages 轮播头图 {large,medium,source,thumbnail}
 *    @return {string} generalName	通用名称	
 *    @return {string} approvalNumber 批准文号	
 *    @return {float} marketPrice	市场价	
 *    @return {int} scoreCount 评分数	
 *    @return {date} monthSalesDate	月销量更新日期
 *    @return {string} caption 副标题	
 *    @return {int} monthSales 月销量	
 *    @return {float} score	评分	
 *    @return {int} productCategoryId	商品分类Id	
 *    @return {float} price	销售价	
 *    @return {int} id 主键
 */
api.findProductInfoById = (data) => {
  return api.requestWithTicket(ApiEnum.findProductInfoById, data, 'POST');
}

/**
 * 获取商品详情推荐商品
 * @param {int} storeId  店铺Id
 * @param {int} productId 产品ID
 * @param {int}	productCategoryId 产品分类
 */
api.getRecommendProduct = (data) => {
  return api.requestWithTicket(ApiEnum.getRecommendProduct, data, 'POST');
}

/**
 * 通过商品id获取优惠券列表
 * @param {int} productId 产品ID
 * @param {int}	memberId 会员ID
 */
api.getCouponByProductId = (data) => {
  return api.requestWithTicket(ApiEnum.getCouponByProductId, data, 'GET');
}

/**
 * 通过商品id获取商品sku列表
 * @param {int} productId 产品ID
 */
api.getSkusByProductId = (data) => {
  return api.requestWithTicket(ApiEnum.getSkusByProductId, data, 'GET');
}

/**
 * 通过商品id获取商品评论
 * @param {int} productId 产品ID
 * @param {int} pageNo 页数（从第0页开始，默认第0页）
 * @param {int} pageSize 每面数据条数（默认10条）
 * @param {string} type 评论类型
 */
api.getReviewList = (data) => {
  return api.requestWithTicket(ApiEnum.getReviewList, data, 'POST');
}

/**
 * 单产品评论数量
 * @param {int} productId 产品ID
 * @param {int} storeId 店铺ID
 */
api.reviewProductCount = (data) => {
  return api.requestWithTicket(ApiEnum.reviewProductCount, data, 'POST');
}

/**
 * 查找商品
 * @param {int} memberId  用户Id
 * @param {Object} params 查询
 *    @return {string} k 要查询字段名 [Y]
 *    @return {int} t 类型 [Y] 设置查询数据的类型：
 *      t=0：模糊查询; t=1：条件查询; t=2：范围查询; t=3：排序
 *    @return {Object} v 查询传值，根据t值要求传值
 *           当t=0时：查询的内容
 *           当t=1时：具体值，可以单值（做=查询），可以是数组（做or查询）
 *                   "v":1 或 "v":"值" 表示单值查询,即=查询 
 *                   "v":[1,2,3] 表示多值查询，即or查询
 *           当t=2时：值—个数组范围，比如查询价格为100到200元之前的商品，值为[100, 200]
 *                    如："v":[1,2];"v":[null, 2];"v":[1,null];
 *           当t=3时：排序值1为正序，-1为倒序
 *    @return {string} url 跳转路径
 *    @return {int} id 分类id主键 
 * @param {int} pageNo 页数（从第0页开始，默认第0页）
 * @param {int} pageSize 分页大小
 */
api.searchProduct = (data) => {
  return api.requestWithTicket(ApiEnum.searchProduct, data, 'POST');
}

/**
 * 设置商品收藏
 * @param {int} productId	产品ID [Y]
 * @param {int} memberId	用户Id [Y]
 */
api.setProductFavorite = (data) => {
  return api.requestWithTicket(ApiEnum.setProductFavorite, data, 'POST');
}

/**
 * 获取收藏的商品
 * @param {int} memberId	用户Id [Y]
 * @param {int} pageNo 页数（从第0页开始，默认第0页）[Y]
 * @param {int} pageSize 每面数据条数（默认10条）
 */
api.getMyFavoriteProduct = (data) => {
  return api.requestWithTicket(ApiEnum.getMyFavoriteProduct, data, 'POST');
}

/**
 * 已加入购物车的产品列表
 * @param {int} storeId 店铺ID
 * 
 * @return {int} id 店铺ID
 * @return {string} name 店铺名
 * @return {string} giftNames	赠品名称
 * @return {bool} isEnabled	是否启用
 * @return {string} promotionNames 促销名称
 * @return {float} discount 折扣
 * @return {string} address 地址
 * @return {string} logo 图
 * @return {Array} cartItems 购物车项
 *    @return {string} name 名字
 *    @return {int} skuId 库存量单位ID
 *    @return {string} skuName 库存量单位名称
 *    @return {string} skuThumbnail	缩略图
 *    @return {int} quantity 数量
 *    @return {float} price 销售价
 *    @return {float} subtotal	小计
 *    @return {bool} isMarketable	是否上架
 *    @return {string} name	产品名称
 *    @return {bool} isMix 是否混批	
 *    @return {bool} isActive	是否有效
 */
api.cartSkuList = (data) => {
  return api.requestWithTicket(ApiEnum.cartSkuList, data, 'POST');
}

/**
 * 加入购物车
 * @param {int} skuId 库存量单位ID [Y]
 * @param {int} quantity 数量 [Y]
 */
api.cartAdds = (data) => {
  return api.requestWithTicket(ApiEnum.cartAdds, data, 'POST');
}

/**
 * 修改购物车中的产品(用于购物车中的单SKU修改)
 * @param {int} skuId 库存量单位ID [Y]
 * @param {int} quantity 数量 [Y]
 */
api.cartModify = (data) => {
  return api.requestWithTicket(ApiEnum.cartModify, data, 'POST');
}

/* 
*获取购物车中的产品种类数量
*/
api.cartKindCount = (data) => {
  return api.requestWithTicket(ApiEnum.cartKindCount, data, 'POST');
}

// checkCartBuy: '0010609',              //立即购买.检查所购买的产品
// createBuy: '0010613',                 //立即购买.提交订单

/**
 * 立即购买.检查所购买的产品
 * @param {int} skuId 库存量单位ID [Y]
 * @param {int} quantity 数量 [Y]
 */
api.checkCartBuy = (data) => {
  return api.requestWithTicket(ApiEnum.checkCartBuy, data, 'POST');
}
/**
 * 立即购买.预加载订单
 * @param {int} skuId 库存量单位ID [Y]
 * @param {int} quantity 数量 [Y]
 */
api.preloadBuy = (data) => {
  return api.requestWithTicket(ApiEnum.preloadBuy, data, 'POST');
}
/**
 * 立即购买.计算订单费用
 * @param {string} 	codes 优惠码字符串数组
 * @param {int} receiverId 收货地址ID
 * @param {int} paymentMethodId 支付方式ID 
 * @param {int} balance 当前余额
 * @param {int} skuId 库存量单位ID 
 * @param {int} quantity 数量 
 * @param {int} shippingMethodId 邮寄方式ID
 * @param {string} memo 备注
 * @param {string} invoiceTitle 发票抬头
 * @param {string} invoiceTaxNumber 税号
 */
api.calculateBuy = (data) => {
  return api.requestWithTicket(ApiEnum.calculateBuy, data, 'POST');
}

/**
 * 立即购买.计算订单费用
 * @param {string} 	codes 优惠码字符串数组
 * @param {int} receiverId 收货地址ID
 * @param {int} paymentMethodId 支付方式ID 
 * @param {int} balance 当前余额
 * @param {int} skuId 库存量单位ID 
 * @param {int} quantity 数量 
 * @param {int} shippingMethodId 邮寄方式ID
 */
api.createBuy = (data) => {
  return api.requestWithTicket(ApiEnum.createBuy, data, 'POST');
}

/**
 * 批量移除购物车产品
 * @param {Array<int>} skuIds 库存量单位ID [Y] 
 *    { [10268,9957,134,135,10703,133,151,10952,10956,398] }
 */
api.cartRemoves = (data) => {
  return api.requestWithTicket(ApiEnum.cartRemoves, data, 'POST');
}

/**
 * 购物车.计算订单费用(当勾选了购物券,配送方式,输入了发票等)
 * @param {Array} codes 优惠码字符串数组
 * @param {int} receiverId 收货地址ID	
 * @param {int} paymentMethodId	支付方式ID	
 * @param {float} balance 当前余额	
 * @param {Array} dtos 源于购物车订单请求参数
 *    @param {int} storeId 店铺Id	
 *    @param {int} shippingMethodId	邮寄方式ID 
 *    @param {string} memo 备注 
 *    @param {int} skuIds 商品ID集 
 *    @param {string} codes 优惠码数组 JSON字符串 
 *    @param {float} price 销售价 
 *    @param {float} subtotal 小计 
 *    @param {bool} isMarketable 是否上架 
 *    @param {string} name 产品名称 
 *    @param {bool} isMix 是否混批 
 *    @param {bool} isActive 是否有效 
 */
api.cartCalculate = (data) => {
  return api.requestWithTicket(ApiEnum.cartCalculate, data, 'POST');
}

/**   
 * 购物车.购物车中结算(点击结算按钮进行勾选的商品的有效性检查)
 * @param {int} cartItemIds	购物车项ID数组	
 */
api.checkCart = (data) => {
  return api.requestWithTicket(ApiEnum.checkCart, data, 'POST');
}

/**   
 * 购物车.预加载订单列表(点击结算按钮出现的页面)
 * @param {int} cartItemIds	购物车项ID数组	
 */
api.preload = (data) => {
  return api.requestWithTicket(ApiEnum.preload, data, 'POST');
}



/**
 * 购物车.提交订单
 * @param {string} codes 优惠码字符串数组 [N]
 * @param {int} receiverId 收货地址ID [N]
 * @param {int} paymentMethodId 支付方式ID [N]
 * @param {float} balance 当前余额 [N]
 * @param {string} invoiceTitle	发票抬头 [N]
 * @param {string} invoiceTaxNumber 税号 [N]
 * @param {Array} dtos 购物车订单 [N] 
 *    storeId、skuIds、shippingMethodId 不能为空；
 *    计算费用是整个列表都要有； 
 *    添加订单时只需要过滤掉 canDelivery 为false的
 *    @param {int} storeId 店铺Id
 *    @param {int} shippingMethodId	邮寄方式ID
 *    @param {string} memo	备注
 *    @param {int} skuIds	商品ID集
 *    @param {string} codes 优惠码字符串数组
 */
api.preorderCreate = (data) => {
  return api.requestWithTicket(ApiEnum.preorderCreate, data, 'POST');
}

/**
 * 通过店铺id获取优惠券列表
 * @param {int} storeId 店铺Id [Y]
 * @param {int} memberId 用户Id [Y]
 * 
 * @return {Array} list 数组
 *     @return {int} id 主键 
 *     @return {string} name 名字 
 *     @return {int} point 兑换积分 
 *     @return {float} minimumPrice 最小价格 
 *     @return {float} maximumPrice 最大价格 
 *     @return {date} beginDate 开始时间
 *     @return {date} endDate 结束时间
 *     @return {float} amt 金额
 *     @return {bool} isReceive 是否已领取
 */
api.getCouponByStoreId = (data) => {
  return api.requestWithTicket(ApiEnum.getCouponByStoreId, data, 'POST');
}

/**
 * 获取可兑换优惠券
 * @param {int} pageNo 页数（从第0页开始，默认第0页）
 * @param {int} pageSize 每面数据条数（默认10条）
 */
api.getHasExchangeCoupons = (data) => {
  return api.requestWithTicket(ApiEnum.getHasExchangeCoupons, data, 'GET');
}

/**
 * 获取我的优惠券
 * @param {int} memberId 状态 
 * @param {int} status 状态 {0:全部，1：已使用， 2：已过期, 3:未使用}
 * @param {int} pageNo 页数（从第0页开始，默认第0页）[Y]
 * @param {int} pageSize 每面数据条数（默认10条）
 */
api.getMyCoupons = (data) => {
  return api.requestWithTicket(ApiEnum.getMyCoupons, data, 'POST');
}

/**
 * 兑换优惠券(领取优惠券)
 * @param {int} memberId 状态 
 * @param {int} couponId 优惠券id
 */
api.couponExchange = (data) => {
  return api.requestWithTicket(ApiEnum.couponExchange, data, 'POST');
}

/**
 * 新人专享优惠券列表
 */
api.getNewCoupons = (data) => {
	return api.requestWithTicket(ApiEnum.getNewCoupons, data, 'POST');
}

/**
 * 通用.获取地区列表	
 * @param {int} parentId 上一级ID [N]
 */
api.areaList = (data) => {
  return api.requestWithTicket(ApiEnum.areaList, data, 'POST');
}

/**
 * 收货地址列表
 * @param {int} pageNo 分页下标
 * @param {int} pageSize 分页大小
 */
api.queryAddrList = (data) => {
  return api.requestWithTicket(ApiEnum.queryAddrList, data, 'POST');
}

/**
 * 添加/修改收货地址
 * @param {string} consignee	收货人 [Y]
 * @param {string} address	地址 [Y]
 * @param {bool} isDefault	是否默认地址 [Y]
 * @param {string} phone	电话号码 [Y]
 * @param {int} areaId	区域ID [Y]
 * @param {int} id	收件地址ID
 * @param {string} areaName	区域名称 
 * @param {string} zipCode	邮编
 */
api.addAddress = (data) => {
  return api.requestWithTicket(ApiEnum.addAddress, data, 'POST');
}

/**
 * 删除收货地址
 * @param {int} id	收件地址ID
 */
api.deleteAddress = (data) => {
  return api.requestWithTicket(ApiEnum.deleteAddress, data, 'POST');
}

/**
 * 获取我的订单列表
 * @param {int} status 订单类型 {
 *      ALL：全部订单； PENDING_PAYMENT:待付款； 
 *      PENDING_SHIPMENT:待发货； SHIPPED:待收货； 
 *      RECEIVED:待评价； COMPLETED:已完成；
 *      PENDING_REVIEW:等待审核； CLOSE:已关闭
 *    }
 * @param {int} memberId 用户ID
 * @param {int} pageNo 页数（从第0页开始，默认第0页）
 * @param {int} pageSize 分页大小
 */
api.getMyOrders = (data) => {
  return api.requestWithTicket(ApiEnum.getMyOrders, data, 'POST');
}

/**
 * 订单详情
 * @param {Array<string>} orderSns 
 * 
 * @return {Array} receiver 收货地址
 *    @return {string} areaName 区域名称
 *    @return {int} id 收件地址ID 长整 
 *    @return {string} consignee 收货人 [Y]
 *    @return {string} address 地址 [Y]
 *    @return {string} zipCode 邮编
 *    @return {bool} isDefault 是否默认地址 [Y]
 *    @return {string} phone 电话号码	[Y]
 * @return {Array} orders 订单
 *    @return {int} id 订单ID
 *    @return {float} price 价格
 *    @return {float} freight 运费
 *    @return {float} amount 订单金额
 *    @return {string} type 类型
 *    @return {string} status 状态
 *    @return {string} shippingMethodName 配送方式名称
 *    @return {bool} isInvoice 是否已开发票 
 *    @return {bool} isReviewed 是否已评论 
 *    @return {bool} isAftersales 是否有售后 
 *    @return {bool} isExpire 是否过期
 * @return {Object} param 可能喜欢的产品请求参数
 *    @return {Object} v 查询传值，根据t值要求传值
 *    @return {string} k 查询字段名 [Y]
 *    @return {int} t 类型 { 设置查询数据的类型： 
 *      t=0：模糊查询； 
 *      t=1：条件查询（=和or）对应v值方式=> "v":1 或 "v":"值" 表示单值查询 
 *           即=查询 "v":[1,2,3] 表示多值查询，即or查询 
 *      t=2：范围查询 如："v":[1,2];"v":[null, 2];"v":[1,null]; 
 *      t=3：排序 v的值只有 -1、0、1三种情况，-1:倒序；0:默认排序；1:正序排序
 *    } [Y]
 *    @return {float} amount	订单金额
 *    @return {string} type	类型
 *    @return {string} status	状态
 *    @return {string} shippingMethodName	配送方式名称
 *    @return {bool} isInvoice	是否已开发票
 *    @return {bool} isReviewed	是否已评论
 *    @return {bool} isAftersales	是否有售后
 *    @return {bool} isExpire	是否过期
 *    @return {string} remark	备注
 *    @return {bool} isCanAftersales 是否可以进行售后
 *    @return {string} statusTxt 状态文本
 *    @return {float} amountPaid	已付金额
 *    @return {int} quantity 数量
 *    @return {string} memo	备注
 *    ...
 */
api.getOrderDetail = (data) => {
  return api.requestWithTicket(ApiEnum.getOrderDetail, data, 'POST');
}

/**
 * 删除订单
 * @param {int} orderId 订单ID
 */
api.delOrder = (data) => {
  return api.requestWithTicket(ApiEnum.delOrder, data, 'POST');
}

/**
 * 取消订单
 * @param {int} sn 订单编号 [Y]
 * @param {string} detail 描述
 * @param {string} remark 备注
 */
api.cancelOrder = (data) => {
  return api.requestWithTicket(ApiEnum.cancelOrder, data, 'POST');
}

/**
 * 订单评论
 * @param {int} orderId 订单ID [Y]
 * @param {int} memberId 用户Id [Y]
 * @param {Array} reviews 评论列表数据
 *    @param {int} orderItemId 订单项ID
 *    @param {string} content 评论内容
 *    @param {string} imageUrls 图片路径集合 JSON字符串
 *    @param {float} score 评分
 */
api.reviewOrder = (data) => {
  return api.requestWithTicket(ApiEnum.reviewOrder, data, 'POST');
}

/**
 * 延时收货或确认收货
 * @param {int} memberId 用户Id [Y]
 * @param {int} orderId 订单ID 
 * @param {int} execType 执行类型 {1:延时收货；2:确认收货}
 */
api.orderChange = (data) => {
  return api.requestWithTicket(ApiEnum.orderChange, data, 'POST');
}

/**
 * 获取我的售后列表
 * @param {int} memberId 用户Id [Y]
 * @param {int} orderId 订单ID 
 * @param {int} pageNo 分页下标
 * @param {int} pageSize 分页大小
 *
 * @return {string} orderSN 编号	
 * @return {string} refundOrderSn 退货单号	
 * @return {string} reason	原因	
 * @return {int} id 主键	
 * @return {string} status	状态 {
 *      PENDING:等待审核；APPROVED:审核通过；FAILED:审核失败；
 *      COMPLETED:已完成；CANCELED:已取消
 *    }
 * @return {string} type	售后类型 {
 *      AFTERSALES_REPAIR：维修；AFTERSALES_REPLACEMENT：换货；
 *      AFTERSALES_RETURNS：退货
 *    }
 * @return {date} lastModifiedDate	时间 
 * @return {Object} store 商店信息 
 *    @return {int} id 商铺ID	
 *    @return {string} name 商铺名称
 *    @return {string} logo 图标
 * @return {Array} aftersalesItems 售后Item 
 *    @return {int} quantity 数量
 *    @return {float} price	销售价
 *    @return {string} name	商品名字
 *    @return {string} sn	编号
 *    @return {int} skuId	库存量单位ID
 *    @return {string} specifications	产品规格
 *    @return {string} thumbnail 略图	
 *    @return {int} productId 产品ID
 */
api.getAftersaless = (data) => {
  return api.requestWithTicket(ApiEnum.getAftersaless, data, 'POST');
}

/**
 * 售后详情
 * @param {int} id 售后id
 * 
 * @return {string} orderSN	订单编号	
 * @return {string} deliveryCorp 物流公司
 * @return {string} deliveryCorpCode 物流公司代码
 * @return {string} trackingNo 运单号	
 * @return {string} reason 原因	
 * @return {date} createdDate	开始时间	
 * @return {date} lastModifiedDate 最后操作时间	
 * @return {string} type 类型	{
 *    AFTERSALES_REPAIR：维修；
 *    AFTERSALES_REPLACEMENT：换货；
 *    AFTERSALES_RETURNS：退货
 * }
 * @return {string} status 状态	{
 *    PENDING:等待审核；APPROVED:审核通过；
 *    FAILED:审核失败；COMPLETED:已完成；CANCELED:已取消
 * }
 * @return {Object} store 商家	
 *    @return {int} id 商铺ID	
 *    @return {string} name 商铺名称	
 *    @return {string} logo	图标
 * @return {Array} aftersalesItems 售后Item
 *    @return {int} quantity 数量		
 *    @return {float} price	销售价	
 *    @return {string} name	商品名字	
 *    @return {string} sn	编号
 *    @return {int} skuId	库存量单位ID	
 *    @return {string} specifications	产品规格	
 *    @return {string} thumbnail 略图	
 *    @return {int} productId	产品ID 
 * @return {Object} repair 维修	{只有当 type=AFTERSALES_REPAIR 时返回}
 *    @return {string} consignee 收货人	
 *    @return {string} area 区域	
 *    @return {string} address	地址	
 *    @return {string} phone	电话	
 *    @return {int} skuId	库存量单位ID	
 *    @return {string} specifications 产品规格	
 *    @return {string} thumbnail 略图 
 *    @return {int} productId	产品ID	
 * @return {Object} returns 售后 - 退货	{只有当 type=AFTERSALES_RETURNS 时返回}
 *    @return {string} account 账户/手机号码
 *    @return {string} method	方式
 *    @return {string} bank 收款银行
 *    @return {string} phone	电话	
 *    @return {int} skuId	库存量单位ID
 *    @return {string} specifications	产品规格
 *    @return {string} thumbnail 略图
 *    @return {int} productId	产品ID
 * @return {Object} replacement 售后 - 维修或换货	{只有当Type=AFTERSALES_REPLACEMENT时返回}
 *    @return {string} consignee	收货人
 *    @return {string} area	区域	
 *    @return {string} address 地址	
 *    @return {string} phone 电话	
 *    @return {int} skuId	库存量单位ID
 *    @return {string} specifications	产品规格 
 *    @return {string} thumbnail 略图	
 *    @return {int} productId	产品ID
 */
api.findAftersales = (data) => {
  return api.requestWithTicket(ApiEnum.findAftersales, data, 'POST');
}

/**
 * 获取订单售后预加载数据
 * @param {int} orderId 订单id [Y]
 */
api.getOrderAfterSaleInfo = (data) => {
  return api.requestWithTicket(ApiEnum.getOrderAfterSaleInfo, data, 'POST');
}

/**
 * 申请售后
 * @param {int} type 申请售后的类型	{1：申请维修；2：申请换货；3：申请退货；}
 * @param {string} sn	订单编号 
 * @param {string} consignee 收货人	{type = 1/2时,必填}
 * @param {string} area	区域名称 {type=1/2时,必填}
 * @param {string} address 详细地址	{type=1/2时,必填}
 * @param {string} phone 电话	{ type=1/2时,必填 }
 * @param {string} account 银行账户	{type=3时必填}
 * @param {string} bank	银行 {type=3时必填}
 * @param {string} method	支付方式名称 {
 *    type=3时必填，值为：ONLINE:在线支付；OFFLINE：线下支付；DEPOSIT：预存款支付
 * }
 * @param {string} reason	申请原因 {必填}
 * @param {string} orderItems	选择的订单商品 {
 *    k：orderItem的id，v:选择的商品/sku数量
 * }
 */
api.applyAfterSale = (data) => {
  return api.requestWithTicket(ApiEnum.applyAfterSale, data, 'POST');
}

/**
 * 取消售后信息
 * @param {int} id 售后id
 */
api.cancelAftersales = (data) => {
  return api.requestWithTicket(ApiEnum.cancelAftersales, data, 'POST');
}


//支付
/**
 * 下单后小程序预支付
 * @param {int} memberId 用户Id [Y]
 * @param {string} orderSns 订单编号 
 */
api.wxappGo = (data) => {
  return api.requestWithTicket(ApiEnum.wxappGo, data, 'POST');
}
/**
 * 小程序支付下单
 * @param {string} orderSns 订单编号 
 */
api.wxappUnifiedOrder = (data) => {
  return api.requestWithTicket(ApiEnum.wxappUnifiedOrder, data, 'POST');
}
/**
 * 小程序支付完成
 * @param {string} tradeNo 交易订单 
 * @param {string} status 交易状态
 */
api.wxappFinish = (data) => {
  return api.requestWithTicket(ApiEnum.wxappFinish, data, 'POST');
}

//微信支付
api.wxPay = (data) => {
  return new Promise((resolve, reject) => {
    wx.requestPayment({
      'timeStamp': data.timeStamp.toString(),
      'nonceStr': data.nonceStr,
      'package': data.package,
      'signType': data.signType,
      'paySign': data.sign,
      success: function (res) {
        resolve(res);
      },
      fail: function (err) {
        // reject(err)
      }
    })
  })
}

/**
 * 服务协议
 */
api.getAppServiceAgreement = (data) => {
  return api.requestWithTicket(ApiEnum.getAppServiceAgreement, data, 'GET');
}

// 查询订单物流
api.getOrderShippingInfo = (orderSn) => {
	return api.requestWithTicket(ApiEnum.getOrderShippingInfo, {orderSn}, 'POST');
}

// 申请推广
api.distributorApply = (data) => {
	return api.requestWithTicket(ApiEnum.distributorApply, data, 'POST');
}

// 我的邀请
api.distributorGetInvites = (data) => {
	return api.requestWithTicket(ApiEnum.distributorGetInvites, data, 'POST');
}

// 我的收益
api.distributionCommission = (data) => {
	return api.requestWithTicket(ApiEnum.distributionCommission, data, 'POST');
}

// 分销优惠商品列表
api.getDistributorCouponProducts = (data) => {
	return api.requestWithTicket(ApiEnum.getDistributorCouponProducts, data, 'POST');
}

// 分销优惠券
api.getDistributorCouponByProductId = (data) => {
	return api.requestWithTicket(ApiEnum.getDistributorCouponByProductId, data, 'POST');
}

// 收益记录
api.getMyDistributionCommissionRecords = (data) => {
	return api.requestWithTicket(ApiEnum.getMyDistributionCommissionRecords, data, 'POST');
}

// 收益详情
api.getMyDistributionCommissionDetails = (data) => {
	return api.requestWithTicket(ApiEnum.getMyDistributionCommissionDetails, data, 'POST');
}

// 佣金结算记录
api.getDistributionCashRecords = (data) => {
	return api.requestWithTicket(ApiEnum.getDistributionCashRecords, data, 'POST');
}

// 会场信息
api.getSpecial = (data) => {
	return api.requestWithTicket(ApiEnum.getSpecial, data, 'POST');
}

// 会场优惠券
api.getCoupons = (data) => {
	return api.requestWithTicket(ApiEnum.getCoupons, data, 'POST');
}

// 领取会场优惠券
api.goCoupon = (data) => {
	return api.requestWithTicket(ApiEnum.goCoupon, data, 'POST');
}

// 会场产品
api.getProducts = (data) => {
	return api.requestWithTicket(ApiEnum.getProducts, data, 'POST');
}

// 组织列表
api.getOrganizationList = (data) => {
	return api.requestWithTicket(ApiEnum.getOrganizationList, data, 'POST');
}

// 切换组织
api.replaceOranization = (data) => {
	return api.requestWithTicket(ApiEnum.replaceOranization, data, 'POST');
}

// 新增代理地址
api.addAgentAddress = (data) => {
	return api.requestWithTicket(ApiEnum.addAgentAddress, data, 'POST');
}

// 组织信息
api.getOrganizationInfo = (data) => {
	return api.requestWithTicket(ApiEnum.getOrganizationInfo, data, 'POST');
}

// 用户代理订单待收货
api.userAgentOrder = (data) => {
	return api.requestWithTicket(ApiEnum.userAgentOrder, data, 'POST');
}

// 用户代理订单待收货
api.userAgentAlreadyOrder = (data) => {
	return api.requestWithTicket(ApiEnum.userAgentAlreadyOrder, data, 'POST');
}

// 一键收货
api.userAgentConfirmOrder = (data) => {
	return api.requestWithTicket(ApiEnum.userAgentConfirmOrder, data, 'POST');
}

// 用户反馈
api.userFeedback = (data) => {
	return api.requestWithTicket(ApiEnum.userFeedback, data, 'POST');
}

// 浏览记录
api.getBrowseRecords = (data) => {
	return api.requestWithTicket(ApiEnum.getBrowseRecords, data, 'POST');
}

// 搜索热词
api.getExporeHotWord = (data) => {
	return api.requestWithTicket(ApiEnum.getExporeHotWord, data, 'POST');
}

export default api