nyx_server/core/admin/Columns.js

Node内容发布

var config = require("../../config/default-config");
var DBTemplate = require("../../db/DBTemplate");
var dbtemplate = new DBTemplate(config.NYX_DB_CONFIG_NAME);
var _ = require("lodash");
var Promise = require("bluebird");

/**
 * column: id
 *          name(栏目名称(创建扣不能修改，是路径))
 *          parent_id(父栏目id)
 *          path(栏目完整路径)
 *          name_path(显示名路径)
 *          descr(栏目描述)
 */


/**
 * 判断节点下是否有相同名称的节点
 * @param parentId 父id
 * @param nodeName 节点名称
 */
function isExistChild(parentId , nodeName){
    var connection = this.connection ||  dbtemplate;
    return getChildren.bind({connection:connection})(parentId).then(function(result){
         for(var i=0; i<result.length; i++){
            var row = result[i];
            console.log(row.name == nodeName);
            if(row.name == nodeName){
                return true;
            }
         }
         return false;
    });
}
module.exports.isExistChild  = isExistChild;




function concatPath(){
    var argsArray = Array.prototype.slice.call(arguments);
    return _.compact(argsArray).join("-")
    //return argsArray.join("-");
}

function splitPath(path){
    return path.split("-");
}

function _addColumn(column) {
    var connection = this.connection ||  dbtemplate;
    var name = column.name;
    var descr = column.descr;
    var parentId = column.parentId;
    var permise = null;
    if (parentId) { //如果parentId不为空则验证父栏目是否存在
        permise = getById.bind({connection: connection})(parentId).then(function(parent) {
            if (!parent) {
                throw new Error("父栏目不存在");
            }
            return parent;
        })
    } else {
        permise = Promise.resolve({});
    }
    return permise.then(function(parent) {
        return isExistChild.bind({connection: connection})(parent.id, name).then(function(exist) {
            if (exist) {
                throw new Error("子栏目已经存在");
            }
            var namePath = concatPath(parent.namePath, name);
            var sql = "insert into column_t(name , parent_id , name_path ,descr) values(?,?,?,?)"
            return connection.query(sql, [name, parentId, namePath, descr]).then(function(result) {
                var id = result.insertId;
                sql = "update column_t set path=? where id=?";
                var path = concatPath(parent.path, id);
                return connection.query(sql, [path, id]).then(function(){
                    return Object.assign({}, column, {
                        id: id,
                        path:path,
                        name_path : namePath
                    });
                });
            });
        })
    })
}

/**
 * 添加子节点
 * @param column    栏目
 * @return 返回新栏目对象，包含id
 */
function addColumn(column){
    return dbtemplate.execute(function(connection){
        return _addColumn.bind({connection:connection})(column);
    });
}
module.exports.addColumn  = addColumn

function toColumnObject(row) {
    return {
        id: row.id,
        name: row.name,
        parentId: row.parent_id,
        path: row.path,
        namePath: row.name_path,
        descr: row.descr
    }
}

/**
 * 得到一个节点
 */
function getById(id){
    var connection = this.connection ||  dbtemplate;
    return connection.query("select * from column_t where id=?" , [id]).then(function(result){
        if(!result || result.length==0){
            return null;
        }
        var row = result[0];
        return toColumnObject(row);
    });
}
module.exports.getById  = getById

function isExist(id){
    var connection = this.connection ||  dbtemplate;
    return getById.bind({connection:connection})(id).then(function(column){
        if(!column){
            throw new Error("栏目不存在")
        }
        return column;
    })
}

/**
 * 删除节点
 * @param nodeId 节点id
 */
function remove(nodeId){
    throw new Error("no implements");
}

/**
 * 移动节点
 * @param childId 节点ID
 * @param fromParentId 原父节点
 * @param toParentId   目标父节点id
 */
function moveTo(childId , fromParentId , toParentId){
     return dbtemplate.execute(function(connection){
         return Promise.all([isExist(childId) , isExist(fromParentId) , isExist(toParentId)])
             .spread(function(child , fromParent , toParent){
                    var sql = "update column_t set parent_id=? where id=?"; //更新当前column的父亲
                    return connection.query(sql , [toParent.id , child.id]).then(function(result){
                        //全面更新子节点下的path
                        if(!result.changedRows){
                            throw new Error("修改栏目失败，没有影响的记录");
                        }
                        return true;
                    }).then(function(){
                        var path = child.path;
                        var toPath = toParent.path;
                        var currentPrefix = concatPath(toPath , child.id);
                        return updateIdPath.bind({connection:connection})(path , currentPrefix);
                    })
             })
     })
     
}
module.exports.moveTo  = moveTo

/**
 * 换名
 * @param nodeId 节点id
 * @param name   待替换的节点名称
 */
function rename(nodeId , name){

    return dbtemplate.execute(function(connection){
        return getById.bind({connection:connection})(nodeId).then(function(column){
            if(!column){
            throw new Error("待修改的栏目不存在") 
            }
            var sql = "update column_t set name=? where id=?";
            return connection.query(sql , [name , nodeId]).then(function(result){
                if(!result.changedRows){
                    throw new Error("修改栏目失败，没有影响的记录");
                }
                return column.name;  //返回原始label
            })
        }).then(function(){
            return getById.bind({connection:connection})(nodeId).then(function(column){
                var originfix = column.namePath; //未调整前的路径
                var names = splitPath(originfix);
                names[names.lenght-1] = name;   //修改后的路径前缀
                var currentPrefix = concatPath.apply(null , names);
                return updateNamePath.bind({connection:connection})(originfix , currentPrefix);
            })
        })
    })
}
module.exports.rename  = rename

/**
 * 更新namePath , 这个功能在数据量大时会出现想能问题
 * @param originPrefix 原始的路径前缀
 * @param prefix       带修改的前缀
 */
function updateNamePath(originPrefix , currentPrefix){
    var connection = this.connection ||  dbtemplate;
    var sql  = "update column_t set name_path=replace(name_path, ? , ?) where name_path like ?%";
    return connection.query(sql , [originPrefix , currentPrefix , originPrefix]).then(function(result){
        return result.affectedRows;
    });
}

/**
 * 更新idPath , 这个功能在数据量大时会出现想能问题
 * @param originPrefix        原始的路径前缀
 * @param currentPrefix       当前修改的前缀
 */
function updateIdPath(originPrefix , currentPrefix){
    var connection = this.connection ||  dbtemplate;
    var sql  = "update column_t set path=replace(path, ? , ?) where name_path like ?%";
    return connection.query(sql , [originPrefix , currentPrefix , originPrefix]).then(function(result){
        return result.affectedRows;
    });
}

/**
 * 得到所有直接子节点
 * @param parentId 父id
 */
function getChildren(parentId){
    var connection = this.connection ||  dbtemplate;
    var sql = ""
    var params = [];
    if(!parentId){
        var sql = "select * from column_t where parent_id is null";
    }else{
        sql = "select * from column_t where parent_id = ?";
        params.push(parentId);
    }

    return connection.query(sql , params).then(function(result){
        if(!result || !result.length){
            return [];
        }
        return result.map(function(row){
            return toColumnObject(row);
        })
    })
}
module.exports.getChildren  = getChildren