loopback-component-package
Version:
Package/Pricing management for loopback API server
276 lines (265 loc) • 8.31 kB
JavaScript
var loopbackUtils = require('loopback/lib/utils');
module.exports=function(Package){
/**
* register new packages
*
* @param {string} package - name of the package
* @param {string} package - either daily, monthly, semiyearly, yearly options
* @param {reset} package - if the package resets when it reaches the end time
* @param {object} cb - callback method
* @return {object} returns newly created package
*/
Package.createPackage=function(name,type,reset,cb){
cb = cb || loopbackUtils.createPromiseCallback();
var PackageUsage = Package.app.models.PackageUsage;
Package.create({
name:name,
type:type,
reset:reset
}).then(function(newPackage){
return cb(null,newPackage);
}).catch(function(err){
return cb(err);
});
return cb.promise;
};
Package.remoteMethod('createPackage', {
description: 'create new package (@type: daily, monthly or yearly)',
accepts: [{
arg: 'name',
type: 'string',
require:true
},{
arg: 'type',
type: 'string',
require:true
},{
arg: 'reset',
type: 'boolean',
require:true,
default:true
}],
returns: {
arg: 'response',
type: 'string',
root:true
},
http: {
verb: 'post'
}
});
/**
*
* register package
*
* @param {string} packageId - reference id for package
* @param {number} limit - maximum limit of package
* @param {bool} isActive - register package as active or inactive
* @param {number} usage - usage (should be 0) but set as you wanted it to start
* @param {object} cb - callback method
* @return {object} returns object containing token
*/
Package.registerPackage=function(packageId,limit,isActive,usage,cb){
cb = cb || loopbackUtils.createPromiseCallback();
var PackageUsage = Package.app.models.PackageUsage;
PackageUsage.create({
packageId:packageId,
isActive:isActive,
limit:limit,
usage:usage
}).then(function(usage){
return cb(null,{
token:usage.id
});
}).catch(function(err){
return cb(err);
});
return cb.promise;
};
Package.remoteMethod('registerPackage', {
description: 'register package',
accepts: [{
arg: 'packageId',
type: 'string',
require:true
},{
arg: 'limit',
type: 'number',
require:true
},{
arg: 'isActive',
type: 'boolean',
require:true,
default:true
},{
arg: 'usage',
type: 'number',
default:0,
require:true
}],
returns: {
arg: 'response',
type: 'string',
root:true
},
http: {
verb: 'post'
}
});
/**
*
* unregister package
* @param {string} token - token string returned when registering a package
* @param {object} cb - callback method
* @return {object} returns object status
*/
Package.unregisterPackage=function(token,cb){
cb = cb || loopbackUtils.createPromiseCallback();
var PackageUsage = Package.app.models.PackageUsage;
PackageUsage.findById(token).then(function(usage){
return usage.updateAttribute("isActive",false);
}).then(function(){
return cb(null,{
status:true
});
}).catch(function(err){
return cb(err);
});
return cb.promise;
};
Package.remoteMethod('unregisterPackage', {
description: 'unregister package',
accepts: [{
arg: 'token',
type: 'string',
require:true
}],
returns: {
arg: 'response',
type: 'string',
root:true
},
http: {
verb: 'post'
}
});
/**
* check package usage if it reached/passed its limit
* @param {string} token - token string returned when registering a package
* @param {number} usage - number of usage that are supposed to be added
* @param {object} cb - callback method
* @return {bool} returns true if the package has'nt reached its limit and false otherwise
*
*/
function checkPackageUsage(token,usage,cb){
cb = cb || loopbackUtils.createPromiseCallback();
var PackageUsage = Package.app.models.PackageUsage;
PackageUsage.findById(token).then(function(package){
if(package){
if((package.usage + usage) <= package.limit){
cb(null,true)
}else{
cb(null,false);
}
}else{
cb(new Error('PackageUsage not found!'))
}
}).catch(function(err){
cb(err);
});
return cb.promise;
}
/**
* register package usage
* @param {string} token - token string returned when registering a package
* @param {number} usage - number of usage that are supposed to be added
* @param {object} cb - callback method
* @return {object} returns object containing current usage count of the package
*/
Package.use=function(token,usage,cb){
cb = cb || loopbackUtils.createPromiseCallback();
var PackageUsage = Package.app.models.PackageUsage;
checkPackageUsage(token,usage).then(function(allowed){
if(allowed){
return PackageUsage.findById(token).then(function(packageUsage){
return packageUsage.updateAttribute('usage',(packageUsage.usage + usage))
}).then(function(newPackage){
return cb(null,{
count:newPackage.usage
});
})
}else{
return cb(null,-1);
}
}).catch(function(err){
return cb(err);
});
return cb.promise;
};
Package.remoteMethod('use', {
description: 'use package',
accepts: [{
arg: 'token',
type: 'string',
require:true
},{
arg: 'usage',
type: 'number',
require:true,
default:0
}],
returns: {
arg: 'response',
type: 'string',
root:true
},
http: {
verb: 'post'
}
});
/**
* unuse package
* @param {string} token - token string returned when registering a package
* @param {number} usage - number of usage that are supposed to be deducted
* @param {object} cb - callback method
* @return {object} returns object containing current usage count of the package
*/
Package.unuse=function(token,usage,cb){
cb = cb || loopbackUtils.createPromiseCallback();
var PackageUsage = Package.app.models.PackageUsage;
PackageUsage.findById(token).then(function(packageUsage){
var usg =(packageUsage.usage - usage);
usg = usg<0?0:usg;
return packageUsage.updateAttribute('usage',usg);
}).then(function(newPackage){
return cb(null,{
count:newPackage.usage
});
}).catch(function(err){
return cb(err);
});
return cb.promise;
};
Package.remoteMethod('unuse', {
description: 'unuse package usage',
accepts: [{
arg: 'token',
type: 'string',
require:true
},{
arg: 'usage',
type: 'number',
require:true,
default:0
}],
returns: {
arg: 'response',
type: 'string',
root:true
},
http: {
verb: 'post'
}
});
return Package;
}