fe / yohobuy-node · Commits

Go to a project

Authored by 周少峰
Commit 63a44ca159b01dbddfe4427a0da158730d6fcb9c 1 parent b2773e53

delete search handler

Inline Side-by-side
Showing 1 changed file with 0 additions and 905 deletions
/*
* @Author: sefon
* @Date: 2016-06-02 15:50:47
* @Last Modified by: Targaryen
* @Last Modified time: 2016-06-22 18:36:26
*/
'use strict';
const _ = require('lodash');
const helpers = global.yoho.helpers;
const queryString = require('querystring');
// 打折、新品、限量
const checksName = {
new: '新品',
specialoffer: '打折',
limited: '限量'
};
/**
* 处理用于筛选的 URL ， 拼接 URL 参数
* @param originParam 当前 URL 中的参数
* @param newParam 要拼接的 参数
* @returns {string}
*/
const handleFilterUrl = (originParam, newParam) => {
let dest = '?';
let tempOriginParam = {};
tempOriginParam = Object.assign(tempOriginParam, originParam, newParam);
delete tempOriginParam.uid;
_.forEach(tempOriginParam, function(value, key) {
dest = dest + key + '=' + value + '&';
});
return _.trim(dest, '&');
};
/**
* 处理选中数据
* @param {[type]} params [description]
* @param {[type]} origin [description]
* @param {[type]} param [description]
* @return {[type]} [description]
*/
const handleCheckedData = (params, origin, param) => {
let dest = [];
if (!_.isEmpty(origin)) {
_.forEach(origin, value => {
if (value.checked) {
let tempPatam = _.cloneDeep(params);
// 删除选中
delete tempPatam[param];
dest.push({
name: value.name,
href: handleFilterUrl(tempPatam)
});
}
});
}
return dest;
};
/**
* 处理品牌筛选数据
* @param params
* @param origin
* @returns {{}}
*/
const handleBrandCheckedData = (params, origin) => {
let dest = [];
// 分拆品牌参数
let brands = _.split(params.brand, ',');
let intBrands = [];
_.forEach(brands, value => {
intBrands.push(parseInt(value, 10));
});
let checkedCount = 0;
// 遍历品牌数据，如果在参数中，那么加 checked，将此数据加入到 checked 数组中
if (!_.isEmpty(origin)) {
_.forEach(origin, (value) => {
if (typeof _.find(intBrands, o => {
return _.isEqual(o, value.id);
}) !== 'undefined') {
let checked = {
name: value.name
}; // push 到已选择数组
// 为了不污染原始数据
let tempIntBrands = _.cloneDeep(intBrands);
// 去掉当前选项
_.remove(tempIntBrands, n => {
return n === value.id;
});
// 拼接参数
let brand = '';
// 建议保留，需要品牌可以单个删除时放开注释即可
// _.forEach(tempIntBrands, subValue => {
// brand += subValue + ',';
// });
// 清除参数，保留没有去掉的参数
let tempParam = {
brand: brand
};
checked.href = handleFilterUrl(params, tempParam);
if (checkedCount === 0) {
dest[0] = checked;
} else if (checkedCount === 1) {
dest[0].name += '、' + checked.name.substring(0, 3) + '...';
}
checkedCount++;
// 建议保留，需要品牌可以单个删除时放开注释即可
// dest.push(checked);
}
});
}
return dest;
};
/**
* 新品、折扣、限量
*/
const hadleChecks = (name, params) => {
let tempParam = _.cloneDeep(params);
tempParam[name] = 'Y';
let checksOpts = {
name: checksName[name],
checked: false,
href: handleFilterUrl(tempParam)
};
if (params[name] && params[name] === 'Y') {
checksOpts.checked = false;
delete tempParam[name];
checksOpts.href = handleFilterUrl(tempParam);
}
return checksOpts;
};
/**
* 处理 opts 排序数据
* @param params
* @param total
* @param extra 什么都可以传进来，多个参数传Object
* @returns {{}}
*/
exports.handleOptsData = (params, total, extra) => {
let dest = {
sortType: [],
checks: []
};
// 用来标记是否是折扣专场，折扣专场只需要前三个排序参数
let count = (extra === 'discont') ? 3 : 4;
for (let i = 0; i < count; i++) {
let opt = {};
switch (i) {
case 0:
opt.href = handleFilterUrl(params, {order: 's_t_desc'});
if (extra === 'discont') { // 如果是折扣专场
opt.name = '全部';
if (_.isEmpty(params.order) || params.order === 's_t_desc') {
opt.active = true;
} else {
opt.active = false;
}
} else {
opt.name = '默认';
opt.hasSortOrient = true;
if (_.isEmpty(params.order) || params.order === 's_n_desc') {
opt.active = true;
} else {
opt.active = false;
}
opt.desc = true;
}
break;
case 1:
if (params.order !== 's_t_desc' && params.order !== 's_t_asc') {
opt.href = handleFilterUrl(params, {order: 's_t_desc'});
opt.hasSortOrient = true;
} else {
opt.hasSortOrient = true;
opt.active = true;
if (params.order === 's_t_desc') {
opt.href = handleFilterUrl(params, {order: 's_t_asc'});
opt.desc = false;
} else {
opt.href = handleFilterUrl(params, {order: 's_t_desc'});
opt.desc = true;
}
}
opt.name = '最新';
break;
case 2:
if (params.order !== 's_p_desc' && params.order !== 's_p_asc') {
opt.href = handleFilterUrl(params, {order: 's_p_desc'});
opt.hasSortOrient = true;
} else {
opt.hasSortOrient = true;
opt.active = true;
if (params.order === 's_p_desc') {
opt.href = handleFilterUrl(params, {order: 's_p_asc'});
opt.desc = false;
} else {
opt.href = handleFilterUrl(params, {order: 's_p_desc'});
opt.desc = true;
}
}
opt.name = '价格';
break;
case 3:
if (params.order !== 'p_d_desc' && params.order !== 'p_d_asc') {
opt.href = handleFilterUrl(params, {order: 'p_d_desc'});
opt.hasSortOrient = true;
} else {
opt.hasSortOrient = true;
opt.active = true;
if (params.order === 'p_d_desc') {
opt.href = handleFilterUrl(params, {order: 'p_d_asc'});
opt.desc = false;
} else {
opt.href = handleFilterUrl(params, {order: 'p_d_desc'});
opt.desc = true;
}
}
opt.name = '折扣';
break;
default:
break;
}
dest.sortType.push(opt);
}
// 上下翻页数据处理
dest.pageCounts = [{
href: handleFilterUrl(params, {limit: 200}),
count: 200
}, {
href: handleFilterUrl(params, {limit: 100}),
count: 100
}, {
href: handleFilterUrl(params, {limit: 60}),
count: 60
}];
dest.curPage = _.isEmpty(params.page) ? 1 : params.page; // 当前页码数
// 每页商品数量
dest.countPerPage = _.isEmpty(params.limit) ? 60 : params.limit;
// 全部页码数量
dest.pageCount = parseInt(total / (_.isEmpty(params.limit) ? 60 : params.limit), 10) + 1;
// 每页多少商品
let paramsLimit = parseInt((_.isEmpty(params.limit) ? 60 : params.limit), 10);
// 上一页下一页
let preHref = (!_.isEmpty(params.page) && parseInt(params.page, 10) > 1) ?
parseInt(params.page, 10) - 1 : 1;
let nextHref = (!_.isEmpty(params.page)) ? parseInt(params.page, 10) + 1 : 2;
if (dest.pageCount > 1 && (parseInt(params.page, 10) !== 1) &&
(parseInt(params.page, 10) !== dest.pageCount)) {
dest.preHref = handleFilterUrl(params, {page: preHref});
dest.nextHref = handleFilterUrl(params, {page: nextHref});
} else if (dest.pageCount > 1 && (parseInt(params.page, 10) === 1)) {
dest.nextHref = handleFilterUrl(params, {page: nextHref});
} else if (dest.pageCount > 1 && (parseInt(params.page, 10) === dest.pageCount)) {
dest.preHref = handleFilterUrl(params, {page: preHref});
}
// 全部商品数
dest.totalCount = total;
// 商品开始结束数
dest.start = (!_.isEmpty(params.page) ? (params.page - 1) : 0) * paramsLimit + 1;
if (total < paramsLimit) {
dest.end = total;
} else {
dest.end = (dest.pageCount === parseInt(params.page, 10)) ?
total : parseInt(dest.start, 10) + paramsLimit - 1;
}
// 新品
if (extra.new === 'Y') {
dest.checks.push(hadleChecks('new', params));
}
// 打折
if (extra.specialoffer === 'Y') {
dest.checks.push(hadleChecks('specialoffer', params));
}
// 限量
if (extra.limited === 'Y') {
dest.checks.push(hadleChecks('limited', params));
}
return dest;
};
/**
* 处理页面左侧分类筛选数据
* @param origin 分类原始数据，一般是接口返回数据中的 group_sort 字段
* @param params 当前 URL 中已有的参数
* @param extra 可以任意传值用来处理特殊情况
* @returns {{}}
*/
exports.handleSortData = (origin, params) => {
let leftContent = {};
leftContent.allSort = {};
leftContent.allSort.list = [];
_.forEach(origin, value => {
let category = {
name: value.sort_name,
num: value.count,
childList: [
{
name: '全部' + value.sort_name,
num: value.count,
href: handleFilterUrl(params, {msort: value.sort_id}),
childActive: params.misort === value.sort_id
}
],
href: handleFilterUrl(params, {msort: value.sort_id}),
active: params.msort === value.sort_id
};
_.forEach(value.sub, subValue => {
category.childList.push({
name: subValue.sort_name,
num: subValue.count,
href: handleFilterUrl(params, {msort: value.sort_id, misort: subValue.sort_id}),
childActive: params.misort === subValue.sort_id
});
if (params.misort === subValue.sort_id) {
category.active = true;
}
});
leftContent.allSort.list.push(category);
});
return leftContent;
};
/**
* 处理一般筛选数据
* @param origin 要处理的筛选数据 filter
* @param params 当前 URL 中已有的参数，处理选中状态使用
* @returns {{}}
*/
exports.handleFilterData = (origin, params) => {
let dest = {
ageLevel: [],
brand: {
default: [],
brandsShow: [],
brandIndex: [{
index: 'all',
name: '全部'
}, {
index: '0-9',
name: '0~9'
}],
showMore: true,
showMulti: true
},
price: [],
gender: [],
color: [],
checkedConditions: {
conditions: []
}
};
// 品牌索引数据处理
for (let i = 65; i < 91; i++) {
dest.brand.brandIndex.push({
index: String.fromCharCode(i).toLowerCase(),
name: String.fromCharCode(i)
});
}
// 品牌数据处理
// 分拆品牌参数
let brands = _.split(params.brand, ',');
let intBrands = [];
_.forEach(brands, value => {
intBrands.push(parseInt(value, 10));
});
if (origin.brand) {
let count = 0;
_.forEach(origin.brand, function(value) {
let brand = {
checked: (typeof _.find(intBrands, o => {
return _.isEqual(o, value.id);
}) !== 'undefined'),
href: handleFilterUrl(params, {brand: value.id}),
name: value.brand_name,
key: value.brand_domain,
id: value.id
};
if (!_.isEmpty(value.brand_alif)) {
if (!_.isNaN(parseInt(value.brand_alif, 10))) {
brand.index = '0-9';
} else {
brand.index = value.brand_alif.toLowerCase();
}
}
if (count < 10) {
dest.brand.default.push(brand);
}
dest.brand.brandsShow.push(brand);
count++;
});
// 没有品牌的情况下将 brand 设置为 false，前端不显示 品牌
if (_.size(dest.brand.brandsShow) <= 0) {
dest.brand = false;
} else {
// 品牌排序
dest.brand.brandsShow = _.sortBy(dest.brand.brandsShow, o => {
return o.index;
});
}
}
// 处理价格筛选数据
let priceRangechecked = false;
if (!_.isEmpty(origin.priceRange)) {
_.forEach(origin.priceRange, (value, key) => {
if (params.price === key) {
priceRangechecked = true;
}
let price = {
checked: params.price === key,
href: handleFilterUrl(params, {price: key}),
name: value
};
dest.price.push(price);
});
}
// 处理用户自主填写的价格区间
if (!priceRangechecked && params.price) {
let customPrice = _.split(params.price, ',');
if (customPrice[1] !== '99999') {
dest.customPrice = {
min: customPrice[0],
max: customPrice[1]
};
dest.checkedConditions.conditions.push({
name: '¥ ' + customPrice[0] + '-' + customPrice[1],
href: handleFilterUrl(params, {price: ''})
});
}
}
// 处理性别数据
dest.gender = [{
name: 'BOYS',
href: handleFilterUrl(params, {gender: '1,3'}),
checked: params.gender === '1,3'
}, {
name: 'GIRLS',
href: handleFilterUrl(params, {gender: '2,3'}),
checked: params.gender === '2,3'
}];
// 尺码处理
if (!_.isEmpty(origin.size) && (params.msort || params.misort || params.sort)) {
dest.size = [];
if (_.isArray(origin.size)) {
_.forEach(origin.size, value => {
dest.size.push({
checked: parseInt(params.size, 10) === parseInt(value.size_id, 10),
href: handleFilterUrl(params, {
size: value.size_id
}),
name: value.size_name
});
});
} else {
dest.size.push({
checked: parseInt(params.size, 10) === parseInt(origin.size.size_id, 10),
href: handleFilterUrl(params, {
size: origin.size.size_id
}),
name: origin.size.size_name
});
}
dest.checkedConditions.conditions = _.union(dest.checkedConditions.conditions,
handleCheckedData(params, dest.size, 'size'));
}
// 处理颜色筛选数据
if (!_.isEmpty(origin.color)) {
_.forEach(origin.color, (value) => {
let color = {
checked: parseInt(params.color, 10) === parseInt(value.color_id, 10),
href: handleFilterUrl(params, {color: value.color_id}),
name: value.color_name,
rgb: value.color_value ? 'url(' + value.color_value + ')' : '#' + value.color_code
};
// 处理颜色选中数据
if (color.checked) {
dest.checkedConditions.conditions.push(color);
}
dest.color.push(color);
});
}
// 处理年龄段
if (!_.isEmpty(origin.ageLevel)) {
_.forEach(origin.ageLevel, (value) => {
let ageLevel = {
checked: params.ageLevel === value.id,
href: handleFilterUrl(params, {ageLevel: value.id}),
name: value.name
};
// 处理颜色年龄段数据
if (ageLevel.checked) {
dest.checkedConditions.conditions.push(ageLevel);
}
dest.ageLevel.push(ageLevel);
});
}
// 清除所有选中数据
let remainParams = {};
if (params.id) {
remainParams.id = params.id;
}
dest.checkedConditions.clearUrl = '?' + queryString.stringify(remainParams);
// 处理频道筛选数据
dest.checkedConditions.conditions = _.union(dest.checkedConditions.conditions,
handleCheckedData(params, dest.gender, 'gender'));
// 处理品牌筛选数据
if (dest.brand.brandsShow) {
dest.checkedConditions.conditions = _.union(dest.checkedConditions.conditions,
handleBrandCheckedData(params, dest.brand.brandsShow));
}
// 处理价格筛选数据
dest.checkedConditions.conditions = _.union(dest.checkedConditions.conditions,
handleCheckedData(params, dest.price, 'price'));
return dest;
};
/**
* 根据页面设置面包屑导航
* @type {[type]}
*/
exports.handlePathNavData = (data, params, page) => {
let pathNav = [{
href: '/',
name: '首页', // TODO 从根据cookie获取频道
pathTitle: '首页'
}];
switch (page) {
case 'search':
// 搜索结果提示
if (params.query || params.keywords) {
params.query = params.query || params.keywords;
pathNav.push({
name: '“<span id="nav_keyword">' +
params.query + '</span>”&nbsp;&nbsp;共<span id="nav_keyword_count">' +
data.total + '</span>个结果'
});
} else {
pathNav.push({
name: '所有商品'
});
}
break;
case 'brand':
// 品牌
pathNav.push(
{
name: '品牌一览',
pathTitle: '品牌一览',
href: helpers.urlFormat('brand')
},
{
name: data.brandNameEn + data.brandNameCn,
pathTitle: data.brandNameEn + data.brandNameCn
}
);
break;
default :
// 分类
_.forEach(data, (sort) => {
if (sort.sort_id === params.msort) {
pathNav.push({
name: sort.sort_name,
href: helpers.urlFormat('/product/outlets/list', {msort: sort.sort_id}),
pathTitle: sort.sort_name
});
}
if (!_.isEmpty(sort.sub)) {
_.forEach(sort.sub, misort => {
if (misort.sort_id === params.misort) {
pathNav.push({
name: misort.sort_name,
pathTitle: misort.sort_name
});
}
});
}
});
break;
}
return {
pathNav: pathNav
};
};
/**
* 分页
* @param {[type]} total 总页数
* @param {[type]} params 筛选条件
* @return {[type]} [description]
*/
exports.handlePagerData = (total, params) => {
let dest = {
prePage: {
url: ''
},
nextPage: {
url: ''
},
pages: []
};
let currentPage = parseInt((_.isEmpty(params.page) ? 1 : params.page), 10); // 当前页
let perPageCount = parseInt((_.isEmpty(params.limit) ? 60 : params.limit), 10); // 每页商品数
let totalPage = parseInt(total / perPageCount, 10) + 1; // 总页数
if (currentPage === 1) {
// 当前页为 1，一定没有上一页
delete dest.prePage;
} else {
dest.prePage.url = handleFilterUrl(params, {page: currentPage - 1});
}
if (currentPage === totalPage) {
// 当前页为最后一页，一定没有下一页
delete dest.nextPage;
} else {
dest.nextPage.url = handleFilterUrl(params, {page: currentPage + 1});
}
// 页码临时数据
let pages = [];
if (currentPage > 2 && currentPage <= totalPage - 2) {
for (let i = currentPage - 2; i <= ((currentPage + 2) > totalPage ? totalPage : (currentPage + 2)); i++) {
pages.push({
url: handleFilterUrl(params, {page: i}),
num: i,
cur: currentPage === i
});
}
// 处理页码小于等于 2 的情况
} else if (currentPage <= 2) {
for (let i = 1; i <= (totalPage < 5 ? totalPage : 5); i++) {
pages.push({
url: handleFilterUrl(params, {page: i}),
num: i,
cur: currentPage === i
});
}
} else if (currentPage > totalPage - 2) {
for (let i = totalPage; i >= totalPage - 4; i--) {
pages.push({
url: handleFilterUrl(params, {page: i}),
num: i,
cur: currentPage === i
});
}
pages = _.sortBy(pages, ['num']);
}
let prevPages = [];
let nextPages = [];
if (_.size(pages) === 5) {
if (currentPage > 4) {
prevPages.push({
url: handleFilterUrl(params, {page: 1}),
num: 1
});
prevPages.push({
num: '...'
});
}
if (currentPage < totalPage - 2) {
nextPages.push({
num: '...'
});
nextPages.push({
url: handleFilterUrl(params, {page: totalPage}),
num: totalPage
});
}
}
// 商品开始结束数
dest.tip = {
total: total,
start: (currentPage ? currentPage - 1 : 0) * perPageCount + 1
};
let endPageNum = (totalPage === currentPage) ?
total : parseInt(dest.tip.start, 10) + perPageCount - 1;
dest.tip.end = (total < perPageCount) ? total : endPageNum;
dest.pages = _.concat(prevPages, pages, nextPages);
return dest;
};
/**
* 处理分类介绍
* @type {[type]}
*/
exports.handleSortIntro = (data, params) => {
let sortIntro = {
name: data.title,
enName: data.subtitle,
description: data.intro,
img: data.logo,
keyEntry: []
};
_.forEach(data.keyword, function(value) {
sortIntro.keyEntry.push({
name: value.word,
url: helpers.urlFormat(value.url, params)
});
});
return sortIntro;
};
/**
* 处理分类页左侧广告
* @type {[type]}
*/
exports.handleSortAds = (data) => {
let sortAds = {
picLink: {
picTitle: '',
list: []
}
};
_.forEach(data, function(value) {
sortAds.picLink.list.push({
href: value.ads_url,
src: value.ads_image
});
});
return sortAds;
};
/**
* 处理一周新品上架
* @type {[type]}
*/
exports.handleWeekNew = (data, params) => {
let dest = {
newSales: {
name: '',
list: []
}
};
_.forEach(data.recent, function(value, key) {
dest.newSales.list.push({
name: key,
href: handleFilterUrl(params, {shelveTime: key}),
active: key === params.shelveTime
});
});
return dest;
};
/**
* 处理搜索提示
* @type {[type]}
*/
exports.handleSuggest = (data) => {
let suggest = [];
_.forEach(data, function(value) {
suggest.push({
href: helpers.urlFormat('', {query: value.keyword}, 'search'),
keyword: value.keyword,
count: value.count
});
});
return suggest;
};
/**
* 处理品牌页banner
* @type {[type]}
*/
exports.handleBrandBanner = (data) => {
return {
bannerHeight: 150,
banner: data.brandBanner.split('?')[0],
brandHome: data.url,
brandIntro: helpers.urlFormat('/about', '', data.brandDomain),
dataId: data.brandId
};
};
/**
* 处理品牌系列
* @type {[type]}
*/
exports.handleFolderData = (data) => {
let dest = [];
_.forEach(data, (value) => {
dest.push({
href: '?series=' + value.id,
src: '?series=' + value.series_banner
});
});
};
/**
* 筛选类链接处理的对外接口
* @type {[type]}
*/
exports.handleFilterUrl = handleFilterUrl;
/**
* 处理选中数据的对外接口
* @type {[type]}
*/
exports.handleCheckedData = handleCheckedData;