this.plugFileSystem = () => co(function *() {
logger.debug('Plugging file system...');
const params = yield paramsP;
that.dal = fileDAL(params);
});
'use strict'
const fs = require("fs");
const co = require('co');
co(function* () {
return yield Promise.resolve(true);
}).then(function (val) {
console.log(val);
throw new Error('error now')
}, function (err) {
console.error(err.stack);
}).catch(function (err) {
console.error(err.stack);
});
Total.updateSyncStatus(0, utility.noop);
// the same time only sync once
var syncing = false;
var handleSync = co(function *() {
debug('mode: %s, syncing: %s', config.syncModel, syncing);
if (!syncing) {
syncing = true;
debug('start syncing');
var data;
var error;
try {
var data = yield *sync();
} catch (err) {
error = err;
}
if (config.debug) {
error && console.error(error.stack);
data && console.log(data);
} else {
sendMailToAdmin(error, data, new Date());
}
syncing = false;
}
});
if (sync) {
handleSync();
setInterval(handleSync, ms(config.syncInterval));
}
it('should return 200', function(done) {
co(function *() {
var res = yield upyun.uploadFile('/lorem/lorem_md5_custom.txt', './LICENSE', true, '69e97c8b91968c5878f331e53b8dcbf4', null);
res.should.have.property('statusCode').be.exactly(200);
})(done)
})
it('should return not found', function(done) {
co(function *() {
var res = yield upyun.uploadFile('/lorem_notfound/lorem.txt', './LICENSE', false, null, null);
res.error.code.should.be.exactly(404);
})(done)
})
value: function _handlerWrapper(handlerFunc, resolved, skipOnError, service, controller, orgOutput) {
if (!orgOutput) {
orgOutput = { out: null, code: 200, headers: null };
}
// error, 40x and 50x codes
if (orgOutput.code && orgOutput.code > 400 && skipOnError) {
return when.resolve(orgOutput);
}
var deferer = when.defer();
var resolveOutput = function resolveOutput(newOutput) {
deferer.resolve(newOutput);
};
// TODO: dependency injection
var done = function done(data, code, headers) {
resolveOutput({
data: data,
code: code || orgOutput.code || 200,
headers: headers
});
};
// TODO: dependency injection
var error = function error(data, code, headers) {
resolveOutput({
data: data,
code: code || 400,
headers: headers
});
};
// TODO: dependency injection
var fatal = function fatal(data, code, headers) {
resolveOutput({
data: data,
code: code || 500,
headers: headers
});
};
// TODO: dependency injection
var custom = function custom(data) {
if (_.isObject(data)) {
if (data.hasOwnProperty('filename')) {
if (!data.header) {
data.headers = {};
}
data.headers.filename = data.filename;
delete data.filename;
}
resolveOutput(data);
} else {
service.logger.error('custom response input must be object');
}
};
// ---------------------------------------
var module = {
'$done': ['value', done],
'$error': ['value', error],
'$fatal': ['value', fatal],
'$custom': ['value', custom],
'$output': ['value', orgOutput || {}]
};
// add resolved to DI
_.forEach(resolved, function (value, key) {
module[key] = ['value', value];
});
// TODO: replace this with DI lib
try {
var result = this._serviceManager.injectionDependency(module, service, controller.instance, handlerFunc);
} catch (err) {
// TODO: fix this so errors are thrown, they seem to be swallowed by DI
error({ error: err.message });
}
// if function is generator then wait on yield
if (util.isES6Function(handlerFunc)) {
try {
// result is generator, so co wrapper it and turn into promise
result = co(result);
} catch (err) {
error({ error: err.message });
}
}
// if result is promise, fire done on the result data
if (when.isPromiseLike(result)) {
result.then(function (output) {
// TODO: figure out better way to handle combined input/vs just data
// API breaking change?
if (output && output.data && output.code) {
done(output.data, output.code, output.headers);
} else {
done(output);
}
}).catch(function (err) {
error({ error: err });
});
}
// if result is not promise and not null or undefined
else if (_.isObject(result) && result.data && result.code) {
// TODO: figure out better way to handle combined input/vs just data
// API breaking change?
done(result.data, result.code, result.headers);
}
// else if result is something
else if (result !== null && result !== undefined) {
done(result);
}
// TODO: is a timer needed here in case handler never resloves the route
return deferer.promise;
}
it('should contain a file list', function(done) {
co(function *() {
var res = yield upyun.listDir('/');
res.should.have.property('data').not.be.empty;
})(done)
})
co(function *() {
// argv parsing
program
.version(version)
.usage('<service> [options]')
.option('-c, --configs-path <c>', 'configs file path')
.option('-s, --sample-configs', 'generate sample configs file')
.option('-l, --log-level <l>', 'logging level (1~5 for debug~critical)',
function(val){return (parseInt(val, 10) - 1) % 5 + 1;})
.parse(process.argv);
// init logging
log.addRule({name: 'stdout', stream: process.stdout,
level: (program.logLevel || 2) * 10});
if (program.sampleConfigs) {
log.info('Generate sample.configs.toml to current directory');
return util.copy(util.path.configs, 'sample.configs.toml');
}
// update configs
var configsPath = program.configsPath || util.path.configs;
var configsContent = fs.readFileSync(configsPath).toString();
util.updateNestedObjects(configs, toml.parse(configsContent));
var name = program.args[0];
if (!name) {
// no service name
program.help();
}
var service = {
listener: require('./lib/listener'),
analyzer: require('./lib/analyzer'),
webapp : require('./lib/webapp'),
alerter : require('./lib/alerter'),
cleaner : require('./lib/cleaner'),
}[name];
if (!service) {
// invalid service name
program.help();
}
// run service
yield service.serve();
}).catch(function(err) {
Resolver.prototype.download = function (branch) {
var task = this._download(branch.resolvedRemotes, branch.name, branch.ref);
this.channel.installs.push(co(task));
}
'use strict';
var co = require('co');
var webdriver = require('pocci/webdriver.js');
co(function*() {
yield webdriver.init();
yield webdriver.browser
.url('http://user:9898/')
.setValue("#login-cn", "admin")
.setValue("#login-userPassword", "admin")
.save("user-admin-berore-autherize")
.click("#login button")
.save("user-admin-after-autherize");
process.exit(0);
}).catch(function(err) {
console.error(err);
process.exit(1);
});
'use strict';
var views = require('co-views');
var parse = require('co-body');
var monk = require('monk');
var wrap = require('co-monk');
// var db = monk('localhost/library');
var mongoose = require('mongoose');
var co = require('co');
var Comment = require('../model/comment');
// console.log(mongoose);
// From lifeofjs
co(function * () {
var comments = yield Comment.find({});
});
var render = views(__dirname + '/../views', {
map: {
html: 'swig'
}
});
// This must be avoided, use ajax in the view.
module.exports.all = function * all(next) {
if ('GET' != this.method) return yield next;
var comments = yield Comment.find({}).populate('poster');
console.log(comments);
this.body = comments;
};
Controller.prototype.delivery = function(viewModels, user){
var shippingController = this.shippingController;
return co(function*(){
yield* _co.coEach(viewModels, function*(viewModel){
viewModel.quantity = _.parseInt(viewModel.quantity);
if(viewModel.quantity === 0)
return;
var shipping = yield model.findOne({_id: objectId(viewModel.shippingId)});
if(!shipping)
return;
var item = _.find(shipping.items, function(item){
return item._id.toString() === viewModel.itemId.toString();
});
if(!item)
return;
var recapitulation = _.find(item.recapitulations, function(recapitulation){
return recapitulation._id.toString() === viewModel.recapitulationId.toString();
});
if(!recapitulation || recapitulation.available === 0)
return;
if(viewModel.quantity > recapitulation.available)
viewModel.quantity = recapitulation.available;
var delivery = {
"recapitulation": recapitulation._id,
"date": new Date(),
"quantity": viewModel.quantity,
"available": viewModel.quantity,
"weight": (item.dimensions.weight / item.colli.quantity) * viewModel.quantity,
"limasColor": viewModel.limasColor,
"relationColor": viewModel.relationColor,
"vehicleNumber": viewModel.vehicleNumber,
"driver": viewModel.driver,
"notes": viewModel.notes,
"created": {
"user": user._id,
"date": new Date()
},
"modified":{ "user": user._id}
};
item.colli.delivered += viewModel.quantity;
recapitulation.available -= viewModel.quantity;
shipping.colli.delivered += viewModel.quantity;
if(item.colli.delivered === item.colli.quantity)
item.status = TERKIRIM;
else
item.status = TERKIRIM_SEBAGIAN;
item.deliveries.push(delivery);
yield shipping.save();
});
});
};
this.loadConf = (useDefaultConf) => co(function *() {
logger.debug('Loading conf...');
that.conf = yield that.dal.loadConf(overrideConf, useDefaultConf);
// Default values
const defaultValues = {
remoteipv6: that.conf.ipv6,
remoteport: that.conf.port,
cpu: constants.DEFAULT_CPU,
c: constants.CONTRACT.DEFAULT.C,
dt: constants.CONTRACT.DEFAULT.DT,
ud0: constants.CONTRACT.DEFAULT.UD0,
stepMax: constants.CONTRACT.DEFAULT.STEPMAX,
sigPeriod: constants.CONTRACT.DEFAULT.SIGPERIOD,
sigStock: constants.CONTRACT.DEFAULT.SIGSTOCK,
sigWindow: constants.CONTRACT.DEFAULT.SIGWINDOW,
sigValidity: constants.CONTRACT.DEFAULT.SIGVALIDITY,
msValidity: constants.CONTRACT.DEFAULT.MSVALIDITY,
sigQty: constants.CONTRACT.DEFAULT.SIGQTY,
idtyWindow: constants.CONTRACT.DEFAULT.IDTYWINDOW,
msWindow: constants.CONTRACT.DEFAULT.MSWINDOW,
xpercent: constants.CONTRACT.DEFAULT.X_PERCENT,
percentRot: constants.CONTRACT.DEFAULT.PERCENTROT,
blocksRot: constants.CONTRACT.DEFAULT.BLOCKSROT,
powDelay: constants.CONTRACT.DEFAULT.POWDELAY,
avgGenTime: constants.CONTRACT.DEFAULT.AVGGENTIME,
dtDiffEval: constants.CONTRACT.DEFAULT.DTDIFFEVAL,
medianTimeBlocks: constants.CONTRACT.DEFAULT.MEDIANTIMEBLOCKS,
rootoffset: 0,
forksize: constants.BRANCHES.DEFAULT_WINDOW_SIZE
};
_.keys(defaultValues).forEach(function(key){
if (that.conf[key] == undefined) {
that.conf[key] = defaultValues[key];
}
});
logger.debug('Loading crypto functions...');
// Extract key pair
let keyPair = null;
const keypairOverriden = overrideConf && (overrideConf.salt || overrideConf.passwd);
if (!keypairOverriden && that.conf.pair) {
keyPair = keyring.Key(that.conf.pair.pub, that.conf.pair.sec);
}
else if (that.conf.passwd || that.conf.salt) {
keyPair = yield keyring.scryptKeyPair(that.conf.salt, that.conf.passwd);
}
else {
keyPair = keyring.Key(constants.CRYPTO.DEFAULT_KEYPAIR.pub,
constants.CRYPTO.DEFAULT_KEYPAIR.sec);
}
if (!keyPair) {
throw Error('This node does not have a keypair. Use `duniter wizard key` to fix this.');
}
that.keyPair = keyPair;
that.sign = keyPair.sign;
// Update services
[that.IdentityService, that.MembershipService, that.PeeringService, that.BlockchainService, that.TransactionsService].map((service) => {
service.setConfDAL(that.conf, that.dal, that.keyPair);
});
that.router().setConfDAL(that.conf, that.dal);
return that.conf;
});
this.unplugFileSystem = () => co(function *() {
logger.debug('Unplugging file system...');
yield that.dal.close();
});
checkUnitBase: (block) => co(function *() {
if (block.dividend > 0 && !(block.unitbase === 0 || block.unitbase > 0))
throw Error('UnitBase must be provided for UD block');
return true;
}),
Object.keys(deps).forEach(function (name) {
ch.push(co(this.resolveDependency(branch, name.toLowerCase(), deps[name])))
}, this)
checkBlockSignature: (block) => co(function *() {
if (!crypto.verify(block.getSignedPart(), block.signature, block.issuer))
throw Error('Block\'s signature must match');
return true;
}),
suite('Extend Task Graph', function() {
var co = require('co');
var get = require('./helper/get');
var cmd = require('./helper/cmd');
var slugid = require('slugid');
var scheduler = new (require('taskcluster-client').Scheduler);
var queue = new (require('taskcluster-client').Queue);
var LocalWorker = require('../dockerworker');
var TestWorker = require('../testworker');
var Task = require('taskcluster-task-factory/task');
var EXTENSION_LABEL = 'test_task_extension';
var worker;
setup(co(function * () {
worker = new TestWorker(LocalWorker);
yield worker.launch();
}));
teardown(co(function* () {
yield worker.terminate();
}));
test('successfully extend graph', co(function* () {
var graphId = slugid.v4();
var primaryTaskId = slugid.v4();
var customTaskId = slugid.v4();
var graphTask = Task.create({
taskGroupId: graphId,
schedulerId: 'task-graph-scheduler',
workerType: worker.workerType,
provisionerId: worker.provisionerId,
metadata: {
description: 'testing',
source: 'http://mytest/',
owner: '*****@*****.**'
},
payload: {
image: 'taskcluster/test-ubuntu',
command: cmd('echo "wooot custom!"'),
features: {},
artifacts: {},
maxRunTime: 5 * 60
}
});
var graph = {
tasks: [{
taskId: customTaskId,
label: EXTENSION_LABEL,
requires: [],
reruns: 0,
task: graphTask
}]
};
var json = JSON.stringify(graph);
var result = yield worker.postToScheduler(graphId, {
metadata: {
source: 'http://xfoobar.com'
},
scopes: [
'queue:define-task:' + worker.provisionerId + '/' + worker.workerType
],
tasks: [{
taskId: primaryTaskId,
label: 'primary',
task: {
metadata: {
owner: '*****@*****.**'
},
payload: {
image: 'taskcluster/test-ubuntu',
command: cmd(
'echo \'' + json + '\' > /graph.json'
),
features: {},
artifacts: {},
graphs: ['/graph.json'],
maxRunTime: 5 * 60
}
}
}]
});
assert.equal(result.length, 2, 'two tasks ran in graph');
var extendingTask = result.filter(function(task) {
return task.taskId === primaryTaskId
})[0];
var customTask = result.filter(function(task) {
return task.taskId === customTaskId;
})[0];
assert.equal(extendingTask.run.state, 'completed', 'extending task should be successful');
assert.equal(extendingTask.run.reasonResolved, 'completed', 'extending task should be successful');
assert.ok(
extendingTask.log.indexOf('extended graph') !== -1,
'log is shown with graph extension'
);
assert.equal(customTask.run.state, 'completed', 'custom task should be successful');
assert.equal(customTask.run.reasonResolved, 'completed', 'custom task should be successful');
assert.ok(
customTask.log.indexOf('wooot custom') !== 1, 'correctly executed commands'
);
}));
test('task failure when graph json is invalid', co(function* () {
var graphId = slugid.v4();
var primaryTaskId = slugid.v4();
var result = yield worker.postToScheduler(graphId, {
metadata: {
source: 'http://xfoobar.com'
},
scopes: [
'queue:define-task:' + worker.provisionerId + '/' + worker.workerType
],
tasks: [{
taskId: primaryTaskId,
label: 'primary',
task: {
metadata: {
owner: '*****@*****.**'
},
payload: {
image: 'taskcluster/test-ubuntu',
command: cmd(
'echo "{foo:bar}" > /graph.json'
),
features: {},
artifacts: {},
graphs: ['/graph.json'],
maxRunTime: 5 * 60
}
}
}]
});
console.log(result[0].log);
assert.ok(
result[0].log.includes("Invalid json in taskgraph extension path"),
'Task graph should have been logged as invalid'
);
assert.ok(
result[0].log.includes('foo:bar'),
'Error message should include contents of invalid json file'
);
assert.ok(
result[0].run.state === 'failed',
'Task should have been marked as failed'
);
}));
test('Update invalid taskgraph id', co(function* () {
var graphId = slugid.v4();
var badGraphId = slugid.v4();
var primaryTaskId = slugid.v4();
var graphTask = Task.create({
taskGroupId: badGraphId,
schedulerId: 'task-graph-scheduler',
workerType: worker.workerType,
provisionerId: worker.provisionerId,
metadata: {
description: 'testing',
source: 'http://mytest/',
owner: '*****@*****.**'
},
payload: {
image: 'taskcluster/test-ubuntu',
command: cmd('echo "wooot custom!"'),
features: {},
artifacts: {},
maxRunTime: 5 * 60
}
});
var graph = {
tasks: [{
taskId: slugid.v4(),
label: EXTENSION_LABEL,
requires: [],
reruns: 0,
task: graphTask
}]
};
var json = JSON.stringify(graph);
var result = yield worker.postToScheduler(graphId, {
metadata: {
source: 'http://xfoobar.com'
},
scopes: [
'queue:define-task:' + worker.provisionerId + '/' + worker.workerType
],
tasks: [{
taskId: primaryTaskId,
label: 'primary',
task: {
metadata: {
owner: '*****@*****.**'
},
payload: {
image: 'taskcluster/test-ubuntu',
command: cmd(
'echo \'' + json + '\' > /graph.json'
),
features: {},
artifacts: {},
graphs: ['/graph.json'],
maxRunTime: 5 * 60
}
}
}]
});
assert.ok(
result[0].log.includes("Graph server error while extending task graph"),
'Task graph error not logged'
);
assert.ok(
result[0].run.state === 'failed',
'Task should have been marked as failed'
);
}));
test('Update graph with invalid task scopes', co(function* () {
var graphId = slugid.v4();
var primaryTaskId = slugid.v4();
var graphTask = Task.create({
taskGroupId: graphId,
schedulerId: 'task-graph-scheduler',
workerType: worker.workerType,
provisionerId: worker.provisionerId,
// Because this scope is not included in the scopes the graph has, extending
// the task graph will fail
scopes: ['this-is-a-bad-scope'],
metadata: {
description: 'testing',
source: 'http://mytest/',
owner: '*****@*****.**'
},
payload: {
image: 'taskcluster/test-ubuntu',
command: cmd('echo "wooot custom!"'),
features: {},
artifacts: {},
maxRunTime: 5 * 60
}
});
var graph = {
tasks: [{
taskId: slugid.v4(),
label: EXTENSION_LABEL,
requires: [],
reruns: 0,
task: graphTask
}]
};
var json = JSON.stringify(graph);
var result = yield worker.postToScheduler(graphId, {
metadata: {
source: 'http://xfoobar.com'
},
scopes: [
'queue:define-task:' + worker.provisionerId + '/' + worker.workerType
],
tasks: [{
taskId: primaryTaskId,
label: 'primary',
task: {
metadata: {
owner: '*****@*****.**'
},
payload: {
image: 'taskcluster/test-ubuntu',
command: cmd(
'echo \'' + json + '\' > /graph.json'
),
features: {},
artifacts: {},
graphs: ['/graph.json'],
maxRunTime: 5 * 60
}
}
}]
});
var log = result[0].log;
assert.ok(
log.includes("Graph server error while extending task graph"),
'Task graph error not logged'
);
assert.ok(
log.includes('You do not have sufficient scopes') && log.includes('this-is-a-bad-scope'),
'Error message did not include authorization failed message'
);
assert.ok(
result[0].run.state === 'failed',
'Task should have been marked as failed'
);
}));
});
it('should contain bucket usage', function(done) {
co(function *() {
var res = yield upyun.getUsage();
res.should.have.property('data').not.be.empty;
})(done)
})
r.tableCreate('user').run(conn, function(err, result) {
if (err && !err.message.match(/Table `.*` already exists/)) {
console.log("Could not create the table `users`");
console.log(err);
process.exit(1);
}
console.log('Table `users` created.');
co(function * () {
var p = new Promise((resolve, reject) => {
r.tableCreate('restaurant').run(conn, function(err, result) {
if (err && !err.message.match(/Table `.*` already exists/)) {
console.log("Could not create the table `users`");
console.log(err);
process.exit(1);
}
console.log('Table restaurant created');
//create location index on restaurant as well!
r.table('restaurant').indexCreate('userID').run(conn, function(err, result) {
if (err) {
console.log(err);
process.exit(1);
}
r.table('restaurant').indexCreate('location', {geo: true}).run(conn, (err, result) => {
if (err) {
console.log(err);
process.exit(1);
}
resolve(result);
});
});
});
});
var q = new Promise((resolve, reject) => {
r.tableCreate('order').run(conn, function(err, result) {
if (err && !err.message.match(/Table `.*` already exists/)) {
console.log("Could not create the table `order`");
console.log(err);
process.exit(1);
}
console.log('Table order created');
r.table('order').indexCreate('userID').run(conn, function(err, result) {
if (err)
console.log(err);
r.table('order').indexCreate('restaurantID').run(conn, function(err, result) {
if (err) {
console.log(err);
process.exit(1);
}
resolve(result);
});
});
});
});
return yield[p,
q];
}).then((value) => {
conn.close();
server.listen(port, () => {
console.log('server is listening on ' + port);
});
});
});
it('should response 200', function(done) {
co(function *() {
var res = yield upyun.removeDir('/createdirtest/');
res.should.have.property('statusCode').be.exactly(200);
})(done)
})
function clone(src, dest) {
return co(function*() {
yield mkdirp(src);
yield ncp(src, dest);
});
}
it('should response 200', function(done) {
co(function *() {
var res = yield upyun.uploadFile('/lorem/lorem_md5.txt', 'TESTTEST', true, true, null);
res.should.have.property('statusCode').be.exactly(200);
})(done)
})
function write(filepath, data) {
return co(function*() {
yield mkdirp(path.dirname(filepath));
yield fs.writeFileAsync(filepath, data);
});
}
'use strict';
var EventEmitter = require('events').EventEmitter,
co = require('co'),
fs = require('co-fs');
var configEmitter = new EventEmitter();
var config = null;
exports.getConfig = function() {
return function(next) {
if (config) {
next(null, config);
} else {
configEmitter.on('parse', next);
}
};
};
co(function* readConfig() {
var file = yield fs.readFile('config.json', 'utf8');
config = JSON.parse(file);
configEmitter.emit('parse', null, config);
});
co(function*() {
// yield any promise
//PORT = yield getUsablePort();
var config = {
host: 'http://' + IPV4,
_host_: IPV4,
};
if (argv[0] === '--production') {
// 生产环境下
webpackConfig.plugins = [
new webpack.DefinePlugin({
'process.env': {
NODE_ENV: '"production"'
}
}),
new webpack.optimize.DedupePlugin(),
new webpack.optimize.UglifyJsPlugin({
compress: {
warnings: false
},
sourceMap: false
}),
new webpack.optimize.OccurenceOrderPlugin(),
new webpack.optimize.AggressiveMergingPlugin(),
new webpack.HotModuleReplacementPlugin()
]
} else {
// 开发环境下
webpackConfig.devtool = '#source-map'
}
var server;
function createServer(_port) {
webpackConfig.entry.app.unshift("webpack-dev-server/client?" + config.host + ":" + _port);
webpackConfig.entry.app.unshift("webpack/hot/dev-server");
var compiler = webpack(webpackConfig);
server = new webpackDevServer(compiler, {
host: config.host,
port: _port,
contentBase: "src/", //指定访问目录
hot: true,
inline: true,
quiet: false,
watchOptions: {
aggregateTimeout: 300,
poll: 1000,
},
//publicPath: config_appName + "/static/", //这个应该是必须的，对应到页面引用js资源的目录，但是没有生成真实的js文件
publicPath: config.host + ":" + _port + "/" + config_appName + "/static/", //这个应该是必须的，对应到页面引用js资源的目录，但是没有生成真实的js文件
headers: {
"X-Custom-Header": "yes"
},
stats: {
colors: true
},
});
server.listen(_port, config._host_, function() {
console.log(config.host + ":" + _port + "/" + config_appName + "/");
open(config.host + ":" + _port + "/" + config_appName + "/");
});
}
serverDomain.run(function() {
createServer(PORT);
});
serverDomain.on('error', function(err) {
server.close();
PORT = PORT + 1;
createServer(PORT);
});
}).catch(onerror);
co(function* (){
yield db.sync({force: true})
let adminObj = yield Admin.create({username: '******', email: '*****@*****.**', password: utils.encryptPassword('admin','admin')})
let adminObj2 = yield Admin.create({username: '******', email: '*****@*****.**', password: utils.encryptPassword('demo','demo')})
let roleObje = yield Role.create({rolename: '超级管理员', roledesc: '超级管理员描述',type:0})
let roleObje2 = yield Role.create({rolename: '普通管理员', roledesc: '普通管理员'})
yield adminObj.addRole([roleObje])
yield adminObj2.addRole([roleObje2])
let menu_sys = yield Menu.create({name: '系统设置', pid: 0, url: '/admin/sys',restype:1,reskey:'sysSet',desc:'系统设置',order:3,icon:'cog'})
let menu_user = yield Menu.create({name: '用户管理', pid: menu_sys.id, url: '/admin/sys/user',restype:2,reskey:'sysUserSet',desc:'用户管理',order:1,icon:'users'})
let menu_res = yield Menu.create({name: '资源管理', pid: menu_sys.id, url: '/admin/sys/res',restype:2,reskey:'resManage',desc:'资源管理',order:2,icon:'file'})
let menu_role = yield Menu.create({name: '角色管理', pid: menu_sys.id, url: '/admin/sys/role',restype:2,reskey:'roleSet',desc:'角色管理',order:3,icon:'envira'})
let menu_addRes = yield Menu.create({name: '添加资源', pid: menu_res.id, url: '/admin/sys/res/add',restype:3,reskey:'resAdd',desc:'添加资源',order:1,icon:''})
let menu_delRes = yield Menu.create({name: '删除资源', pid: menu_res.id, url: '/admin/sys/res/del',restype:3,reskey:'resDel',desc:'删除资源',order:2,icon:''})
let menu_editRes = yield Menu.create({name: '修改资源', pid: menu_res.id, url: '/admin/sys/res/edit',restype:3,reskey:'editRes',desc:'修改资源',order:3,icon:''})
let menu_addRole = yield Menu.create({name: '添加角色', pid: menu_role.id, url: '/admin/sys/role/add',restype:3,reskey:'roleAdd',desc:'添加角色',order:1,icon:''})
let menu_delRole = yield Menu.create({name: '删除角色', pid: menu_role.id, url: '/admin/sys/role/del',restype:3,reskey:'roleDel',desc:'删除角色',order:2,icon:''})
let menu_editRole = yield Menu.create({name: '修改角色', pid: menu_role.id, url: '/admin/sys/role/edit',restype:3,reskey:'roleEdit',desc:'修改角色',order:3,icon:''})
let menu_aclRole = yield Menu.create({name: '查看权限列表', pid: menu_role.id, url: '/admin/sys/role/acl',restype:3,reskey:'roleList',desc:'查看权限列表',order:3,icon:''})
let menu_aclSetRole = yield Menu.create({name: '权限配置', pid: menu_role.id, url: '/admin/sys/role/aclSet',restype:3,reskey:'roleSet',desc:'权限配置',order:3,icon:''})
let menu_detailRole = yield Menu.create({name: '查看角色详细', pid: menu_role.id, url: '/admin/sys/role/roleDetail',restype:3,reskey:'roleDetail',desc:'查看角色详细',order:3,icon:''})
let menu_detailRes = yield Menu.create({name: '查看资源详细', pid: menu_res.id, url: '/admin/sys/res/resDetail',restype:3,reskey:'resDetail',desc:'查看资源详细',order:3,icon:''})
let menu_delUser = yield Menu.create({name: '删除用户', pid: menu_user.id, url: '/admin/sys/user/del',restype:3,reskey:'userDel',desc:'删除用户',order:3,icon:''})
let menu_editUser = yield Menu.create({name: '修改用户信息', pid: menu_user.id, url: '/admin/sys/user/edit',restype:3,reskey:'userEdit',desc:'修改用户信息,角色',order:3,icon:''})
let menu_createUser = yield Menu.create({name: '创建用户', pid: menu_user.id, url: '/admin/sys/user/create',restype:3,reskey:'userCreate',desc:'创建用户',order:3,icon:''})
let menu_detailUser = yield Menu.create({name: '获取用户详细', pid: menu_user.id, url: '/admin/sys/user/detail',restype:3,reskey:'userDetail',desc:'获取用户详细信息',order:3,icon:''})
/*********以下都是非网站基础功能,是业务和项目相关的*******/
//监控管理
let menu_monitor = yield Menu.create({name: '监控管理', pid: 0, url: '/admin/monitor',restype:1,reskey:'monitor',desc:'监控管理',order:1,icon:'user-secret'})
let menu_monitor_interface = yield Menu.create({name: '接口监控', pid: menu_monitor.id, url: '/admin/monitor/interface',restype:2,reskey:'monitor_interface',desc:'接口监控',order:4,icon:'binoculars'})
let menu_monitor_server = yield Menu.create({name: '服务器监控', pid: menu_monitor.id, url: '/admin/monitor/server',restype:2,reskey:'monitor_server',desc:'服务器监控',order:4,icon:'binoculars'})
/*********以上都是非网站基础功能,是业务和项目相关的*******/
//给超级管理员预制权限
yield roleObje.addMenu([
menu_sys,
menu_user,
menu_res,
menu_role,
menu_addRes,
menu_delRes,
menu_editRes,
menu_addRole,
menu_delRole,
menu_editRole,
menu_aclRole,
menu_aclSetRole,
menu_detailRole,
menu_detailRes,
menu_delUser,
menu_editUser,
menu_createUser,
menu_detailUser,
/*********以下都是非网站基础功能,是业务和项目相关的*******/
menu_monitor,
menu_monitor_interface,
menu_monitor_server])
//普通管理员权限预制
yield roleObje2.addMenu([
menu_monitor,
menu_monitor_interface,
menu_monitor_server
])
//yield db.query("CALL menu_templst(0);")
console.log('ok ... everything is nice for DB!')
}).catch(function(e){
//Shows entire HTTP response and its body
"use strict";
let co = require('co');
let request = require('../');
co(function* () {
let response = yield request('http://google.com');
let body = response.body;
console.log('Response: ', response);
console.log('Body: ', body);
}).catch(function (err) {
console.err(err);
});
objs.forEach(function (obj) {
ch.push(co(this.getFile(repo, ref, obj, tmp)))
}, this)
this.writeRaw = (raw, type) => co(function *() {
const parser = documentsMapping[type] && documentsMapping[type].parser;
const obj = parser.syncWrite(raw);
return yield that.singleWritePromise(obj);
});