gulp.task('ngconstant', function() {
return es.merge(
gulp.src('./www/json/config.' + ENV + '.json')
.pipe(ngConstant({
name: 'app.const',
wrap: '(function() { <%= __ngModule %> })();',
stream: true,
constants: {
CONFIG: require('./www/json/config.' + ENV + '.json')
}
}))
.pipe(rename('app.const.js'))
.pipe(gulp.dest('./www/js')),
gulp.src('./www/json/lang/' + CONFIG.lang + '.json')
.pipe(ngConstant({
name: 'app.defaultLang',
wrap: '(function() { <%= __ngModule %> })();',
stream: true,
constants: {
defaultLang: {
name: CONFIG.lang,
values: require('./www/json/lang/' + CONFIG.lang + '.json')
}
}
}))
.pipe(rename('app.defaultLang.js'))
.pipe(gulp.dest('./www/js/'))
);
});
gulp.task('constant', function () {
gulp.src('app/constant.json')
.pipe(gulpif(inProduction,
ngConstant({
name: 'platform.constant',
constants: { apiUrl: process.env.API_URL },
wrap: 'amd',
}),
ngConstant())
)
.pipe(gulp.dest('dist'));
});
gulp.task('js', function(config) {
config = JSON.parse(config);
return streamqueue({objectMode: true},
gulp.src([
'node_modules/angular/angular.min.js',
'node_modules/angular-route/angular-route.js',
'node_modules/angular-gettext/dist/angular-gettext.min.js',
'node_modules/angular-strap/dist/modules/compiler.min.js',
'node_modules/angular-strap/dist/modules/dimensions.min.js',
'node_modules/angular-strap/dist/modules/modal.min.js',
'node_modules/sjcl/sjcl.js',
'node_modules/sjcl/core/codecBytes.js',
'node_modules/clipboard/dist/clipboard.min.js',
'frontend/locales/*.po',
'frontend/scripts/*.js'
]),
ngConstant({
constants: {
config: {
acceptedTypes: config.acceptedTypes,
maxSize: config.maxSize
}
},
stream: true,
name: 'imgbi.config'
})
)
.pipe(cache('scripts'))
.pipe(gulpif(/[.]po$/, gettext.compile()))
.pipe(remember('scripts'))
.pipe(concat('main.js'))
.pipe(uglify())
.pipe(gulp.dest(config.staticContent + '/scripts'));
});
module.exports = function buildConfig() {
//Create file stream for configuration file
let stream = file('app.config.js', JSON.stringify({}), {src: true})
.pipe(ngConstant({
name: angularModuleName('Config'),
stream: true,
constants: {
Config: config,
},
}))
.pipe(rename('app.config.js'))
.pipe(plumber())
.pipe(babel({
compact: false,
}))
.on('error', console.error)
.pipe(ngAnnotate())
.pipe(wrapper(angularWrapper()));
//Minify
if (build.BUNDLE_JS) {
stream = stream
.pipe(concat(packageFilename('.config.min.js')))
.pipe(uglify());
}
//Write to destination folder and return
return stream.pipe(gulp.dest(build.DEST_JS));
};
function configTask () {
return gulp.src('./config.json')
.pipe(ngConstant({
name: 'app.config'
}))
.pipe(gulp.dest(path.build));
}
gulp.task('generate:ConstantModule', 'Create constants module', function() {
if(prod){
var environment = 'production';
}else{
var environment = 'development';
}
var constants = config.constants;
if(prod){
constants.cache_buster = Math.random().toString(16).slice(2);
}
for (var constant in config.environment[environment]){
constants[constant] = config.environment[environment][constant];
}
return ngConstant({
constants: constants,
templatePath: config.ngconstants.tpl,
stream: true
})
.pipe(gulpif(mocks, replace('mocks: false', 'mocks: true')))
.pipe(gulpif(!mocks, replace('mocks: true', 'mocks: false')))
.pipe(rename(config.ngconstants.name))
.pipe(gulp.dest(config.ngconstants.dest));
});
gulp.task('config', function () {
gulp.src(envPath)
.pipe(ngConstant({
name: 'app.config'
}))
.pipe(rename('config.js'))
.pipe(gulp.dest('./src/app/common/modules'));
});
return function() {
return ngConstant({
name: 'modules.generated',
constants: constants,
stream: true
})
.pipe(gulp.dest(paths.client.generatedDir));
}
var config = function(src) {
return gulp.src(src)
.pipe(ngConstant())
.pipe(rename(function (path) {
path.basename = 'config'
}))
.pipe(gulp.dest('app/scripts'));
}
gulp.task('config:dist', function() {
var myConfig = require(path.join('..', conf.paths.config));
var envConfig = myConfig['prod'];
return ngConstant({
constants : envConfig,
stream : true,
name : 'config'
}).pipe(gulp.dest(path.join(conf.paths.src, '/app/')));
});
gulp.task('ng-constants', function () {
return gulp
.src(paths.src + 'javascripts/app/constants.json')
.pipe(ngConstant({
name: 'cla.constants'
}))
// Writes config.js to dist folder
.pipe(gulp.dest(paths.tmp + 'javascripts/app/js/'));
});
gulp.task('build:config', function () {
return gulp.src('./config/' + (ENV_PRODUCTION ? 'production' : 'development') + '.json')
.pipe(ngConstant({
name: 'ngApp.config'
}))
.pipe(rename('config.js'))
.pipe(gulpif(ENV_PRODUCTION, uglify()))
.pipe(gulp.dest(TARGET_DIR));
});
gulp.task('constants', function() {
var configFile = require('../config.json');
var envConfig = configFile[environment];
return ngConstant({
name: configFile.name,
constants: envConfig,
stream: true
})
.pipe(gulp.dest(paths.dest.output));
});
gulp.task('config', function () {
var myConfig = require('../config.json');
var envConfig = myConfig['constants'][process.env.NODE_ENV];
return ngConstant({
name: myConfig.name,
deps: myConfig.deps,
constants: envConfig,
stream: true
}).pipe(gulp.dest('src/app/'));
});
gulp.task('config-hostname', function () {
gulp.src('src/app/config-' + environment + '.json')
.pipe(ngConstant({
name: 'NourritureServices',
dest: 'config.js',
merge: true
}))
.pipe(rename("index.constants.js"))
.pipe(gulp.dest('src/app/'));
});
gulp.task('constants', function (done) {
var env = (gutil.env.production ? 'production' : 'development');
var constnats = require('./config/' + env + '.json');
return ngConstant({
name: 'app.config',
deps: [],
constants: constnats,
stream: true
})
.pipe(gulp.dest(paths.www + 'js'));
});
gulp.task('constants', function () {
var myConfig = require('./config.json');
var apiUrl = myConfig.Api[myConfig.AppSettings.apiType];
var envConfig = { apiUrl: apiUrl };
return ngConstant({
name: 'environments.config',
constants: envConfig,
stream: true
}).pipe(gulp.dest('Scripts'));
});
gulp.task('config', function() {
return gulp.src('.').pipe(rename('config.js')).pipe(ngConstant({
name : 'config',
constants : {
config : {
backendUrl : 'https://api.parse.com/1/'
//backendUrl : 'http://backend.dulcet-theory-91214.appspot.com/'
}
}
})).pipe(gulp.dest('build/js/'));
});
gulp.task('constants', function () {
var myConfig = require(environment_configfile);
var envConfig = myConfig[process.env.NODE_ENV];
return ngConstant({
name: 'app.core',
stream: true,
constants: envConfig,
templatePath: './public/constant.tpl.ejs'
})
.pipe(gulp.dest(constants_output));
});
function(err, info) {
var revision = info.entry.$.revision;
console.log('Current working copy is at revision: ' + revision);
var versionJson = require('version.template.json');
versionJson.VERSION.REVISION = revision;
gulp.src('version.template.json').pipe(ngConstant({
name: 'versioning-example.version',
constants: versionJson
}))
.pipe(rename('version.js'))
.pipe(gulp.dest('src/app/scripts'));
});
gulp.task('config', function() {
var env = process.env.env || 'local';
var config = require('./data/config.json')[env];
return ngConstant({
constants: config,
name: 'app.core.config',
stream: true,
deps: false
})
.pipe(gulp.dest('./dist'));
});
gulp.task('ngconstant:prod', function () {
return ngConstant({
name: 'kevoreeRegistryApp',
constants: {
VERSION: util.parseVersion(),
DEBUG_INFO_ENABLED: false
},
template: config.constantTemplate,
stream: true
}).pipe(rename('app.constants.js'))
.pipe(gulp.dest(config.app + 'app/'));
});
gulp.task('config', function () {
var myConfig = require('../config.json');
var envConfig = myConfig[options.env];
return ngConstant({
constants: envConfig,
name: 'youomi.configs',
stream: true,
wrap: '/* jshint ignore:start */<%= __ngModule %>/* jshint ignore:end */'
})
.pipe(gulp.dest('src/app'));
});
gulp.task('config', function () {
var config = gulp.src('config/' + enviroment + '.json')
.pipe(ngConstant({
name: 'portal.constants',
space: ' ',
wrap: "(function() {\n 'use strict';\n\n<%= __ngModule %>\n})();"
}));
var scripts = gulp.src('js/*');
return es.merge(config, scripts)
.pipe(concat('index.constants.js'))
.pipe(gulp.dest('src/app'))
.on('error', function() { });
});
var config = function(env) {
gulp.src(['./src/app/config/config.default.json', 'src/app/config/config.' + env + '.json'])
.pipe(extend('config.json', true))
.pipe(ngConstant({
name: 'starter.configs',
deps: [],
}))
.pipe(rename(function(path) {
path.basename = 'config';
path.extname = '.js';
}))
.pipe(gulp.dest('src/app/config'));
};
gulp.task('ngconstant:dev', function () {
return ngConstant({
name: 'tabulaRasaApp',
constants: {
VERSION: util.parseVersion(),
DEBUG_INFO_ENABLED: true
},
template: config.constantTemplate,
stream: true
})
.pipe(rename('app.constants.js'))
.pipe(gulp.dest(config.app + 'app/'));
});
gulp.task('constants:development', function () {
var constants = {
ENV: config.ENV,
API_HOST: argv['api-host'] || process.env.API_HOST || config.API_HOST,
GA_TRACKING_ID: config.GA_TRACKING_ID
};
return ngConstant({
name: config.module,
constants: constants,
stream: true
}).pipe(rename({basename: config.filename}))
.pipe(gulp.dest(config.dest));
});
gulp.task('config', function () {
var appConfig = readConfig();
appConfig.version = pkg.version;
return ngConstant({
name: 'janusHangouts.config',
constants: appConfig,
stream: true,
space: ' ',
templatePath: 'gulp/config.tpl.ejs'
})
.pipe(rename('config.js'))
.pipe(gulp.dest('src/app'));
});
gulp.task('build', function () {
var user = argv.user || 'will'; //default
var constantsStream = ngConstant({
name: 'audiodio.constants',
constants: config.usernames[user],
stream: true
});
var appStream = gulp.src('./www/app/**/*.js');
return merge(appStream, constantsStream)
.pipe(concat('audiodio.js'))
.pipe(gulp.dest('./www/'));
});
gulp.task('ngconstant:prod', function () {
return ngConstant({
name: 'service1App',
constants: {
VERSION: util.parseVersion(),
DEBUG_INFO_ENABLED: false,
BUILD_TIMESTAMP: new Date().getTime()
},
template: config.constantTemplate,
stream: true
})
.pipe(rename('app.constants.js'))
.pipe(gulp.dest(config.app + 'app/'));
});