you-yuan-uni-ui/utils/paramToFreeSqlFilter.js

you-yuan-uni-ui 组件库

/**
 * 时间格式化
 * Parse the time to string
 * @param {(Object|string|number)} time
 * @param {string} cFormat
 * @returns {string}
 */
export function parseTime(time, cFormat) {
  // arguments.length 代表传参的个数
  if (arguments.length === 0) {
    return null;
  }
  const format = cFormat || '{y}-{m}-{d} {h}:{i}:{s}';
  if (!time) {
    return '';
  }
  let date;
  if (typeof time === 'object') {
    date = time;
  } else {
    if (typeof time === 'string' && /^[0-9]+$/.test(time)) {
      time = parseInt(time);
    }
    if (typeof time === 'number' && time.toString().length === 10) {
      time = time * 1000;
    }
    date = new Date(time);
  }
  const formatObj = {
    y: date.getFullYear(),
    m: date.getMonth() + 1,
    d: date.getDate(),
    h: date.getHours(),
    i: date.getMinutes(),
    s: date.getSeconds(),
    a: date.getDay()
  };
  // eslint-disable-next-line camelcase
  const time_str = format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
    let value = formatObj[key];
    // Note: getDay() returns 0 on Sunday
    if (key === 'a') {
      return ['日', '一', '二', '三', '四', '五', '六'][value];
    }
    if (result.length > 0 && value < 10) {
      value = '0' + value;
    }
    return value || 0;
  });
  // eslint-disable-next-line camelcase
  return time_str;
}

/**
 * 定义好的operator列表
 */
const operateOptions = [
  { value: 0, label: '包含', operator: 'Contains' },
  { value: 0, label: '包含', operator: 'Like' },
  { value: 1, label: '起始于', operator: 'StartsWith' },
  { value: 2, label: '结束于', operator: 'EndsWith' },
  { value: 3, label: '不包含', operator: 'NotContains' },
  { value: 4, label: '不起始于', operator: 'NotStartsWith' },
  { value: 5, label: '不结束于', operator: 'NotEndsWith' },
  { value: 6, label: '等于', operator: 'Equal' },
  // { value: 7, label: '等于', operator: 'Equals' },
  // { value: 8, label: '等于', operator: 'Eq' },
  { value: 9, label: '不等于', operator: 'NotEqual' },
  { value: 10, label: '大于', operator: 'GreaterThan' },
  { value: 11, label: '大于等于', operator: 'GreaterThanOrEqual' },
  { value: 12, label: '小于', operator: 'LessThan' },
  { value: 13, label: '小于等于', operator: 'LessThanOrEqual' },
  { value: 14, label: '介于两者之间', operator: 'Range' },
  { value: 15, label: '介于两个时间之间', operator: 'DateRange' },
  { value: 16, label: '包含任意一个', operator: 'Any' },
  { value: 17, label: '不包含任意一个', operator: 'NotAny' }
].map((item) => item.operator);

/**
 * 兼容 将 like 转为 contains
 * @param {Object} operator
 */
function getLike(operator) {
  if (operator === 'Like') {
    return 'Contains';
  }
  return operator;
}

/**
 * 处理字段是 Partner_Name_Like的情况
 */
function formatKeyLine(key) {
  let arr = [key];
  try {
    operateOptions.forEach((el) => {
      if (key.endsWith('_' + el)) {
        throw [el];
      }
      if (key.endsWith('_' + el + '_empty')) {
        throw [el, 'empty'];
      }
      if (key.endsWith('_' + el + '_Empty')) {
        throw [el, 'Empty'];
      }
    });
  } catch (e) {
    // 有自定义的操作
    arr[0] = key.split('_' + e[0])[0];
    arr[1] = e[0];
    if (e[1]) {
      arr[0] = key.split('_' + e[0] + '_' + e[1])[0];
      arr[2] = e[1];
    }
  }

  return arr;
}

/**
 * 将普通的对象转为.net freesql 能识别的数据类型
 * @param {Object} obj
 */
function obj2DianNetFreeSql(obj = {}) {
  const Filters = [];
  // console.log("sql 参数转换", obj)
  for (const key in obj) {
    // 排除自定义的数据格式
    if (!['page', 'pageSize', 'asc', 'desc', 'or', 'or_column', 'or_keywords'].includes(key)) {
      let arr = formatKeyLine(key);
      console.log('sql 参数转换', arr);
      if (arr.length == 1) {
        if (![null, undefined, ''].includes(obj[key])) {
          Filters.push({
            Field: arr[0],
            Value: obj[key],
            Operator: 'Equals'
          });
        }
      } else if (arr.length == 2) {
        // 正常情况 Partner_Name_Like 的情况
        if (obj[key]) {
          const value = obj[key];
          const operator = getLike(arr[1]);
          if (operator == 'DateRange') {
            const endTime = value[1];
            if (Array.isArray(value) && endTime) {
              // 只有传时分秒的时候才格式化
              if (endTime.split(' ').length > 1) value[1] = parseTime(endTime, '{y}-{m}-{d} {h}:{i}');
            }
          }

          Filters.push({
            Field: arr[0],
            Value: value,
            Operator: getLike(arr[1])
          });
        }
      } else if (arr.length == 3) {
        // 判断为 Partner_Name_Equals_empty 的情况
        Filters.push({
          Field: arr[0],
          Value: obj[key],
          Operator: getLike(arr[1])
        });
      }
    }
    // 处理 or 查询
    if (key === 'or' && Object.prototype.toString.call(obj[key]) === '[object Object]') {
      const Filters2 = obj2DianNetFreeSql(obj[key]);
      if (Filters2.length)
        Filters.push({
          name: 'orFilter', // 仅做标识，并不生效
          Logic: 'or',
          Filters: Filters2
        });
    }
    // 处理 or_column 查询 {columns:[],keyword:'',operator:''}
    if (key === 'or_column' && Object.prototype.toString.call(obj[key]) === '[object Object]') {
      const columns = obj[key].columns;
      if (obj[key].keyword) {
        if (columns && Object.prototype.toString.call(columns) === '[object Array]') {
          const Filters2 = [];
          columns.forEach((col) => {
            Filters2.push({
              Field: col,
              Value: obj[key].keyword || '',
              Operator: getLike(obj[key].operator) || 'Contains'
            });
          });

          if (Filters2.length)
            Filters.push({
              name: 'orFilter', // 仅做标识，并不生效
              Logic: 'or',
              Filters: Filters2
            });
        }
      }
    }
    // 处理，or_keywords 查询 {column:'',keywords:[],operator:''}
    if (key === 'or_keywords' && Object.prototype.toString.call(obj[key]) === '[object Object]') {
      const keywords = obj[key].keywords;
      // console.log(obj[key])
      if (keywords && Object.prototype.toString.call(keywords) === '[object Array]') {
        const Filters2 = [];
        keywords.forEach((value) => {
          if (value)
            Filters2.push({
              Field: obj[key].column,
              Value: value || '',
              Operator: getLike(obj[key].operator) || 'Contains'
            });
        });
        // console.log(Filters2)
        if (Filters2.length)
          Filters.push({
            name: 'orFilter', // 仅做标识，并不生效
            Logic: 'or',
            Filters: Filters2
          });
      }
    }
  }

  return Filters;
}

/**
 * 用于将普通对象直接转为freeSQL查询使用的标准对象
 */
export function getPageFilterObj(params = {}, parentParams = {}) {
  const finalParams = {
    Rows: params.pageSize,
    Page: params.page,
    SordField: params.desc ? params.desc : params.asc ? params.asc : '',
    IsAscending: params.asc ? true : false,
    FilterInfo: {
      Logic: 'and',
      Filters: obj2DianNetFreeSql(params)
    },
    ...parentParams
  };
  return finalParams;
}

export function getPageFilterObjUseStatus(params = {}) {
  params['Status'] = 1;
  return getPageFilterObj(params);
}

export function getFilterObj(params = {}, parentParams = {}) {
  const finalParams = {
    Logic: 'And',
    Filters: obj2DianNetFreeSql(params),
    ...parentParams
  };

  return finalParams;
}

export function getFilterObjUseStatus(params = {}) {
  params['Status'] = 1;
  return getFilterObj(params);
}