From f4c2bb6e5b23629b54a5045e724fc3050c0755f7 Mon Sep 17 00:00:00 2001 From: Phil Kunz Date: Mon, 16 May 2016 03:29:29 +0200 Subject: [PATCH] add functionality --- dist/cflare.classes.cflareaccount.d.ts | 6 ++- dist/cflare.classes.cflareaccount.js | 45 ++++++++++++++++++--- package.json | 3 +- test/test.js | 37 ++++++++++++++++- test/test.ts | 35 ++++++++++++++++ ts/cflare.classes.cflareaccount.ts | 55 ++++++++++++++++++++++---- ts/typings.json | 1 + 7 files changed, 166 insertions(+), 16 deletions(-) diff --git a/dist/cflare.classes.cflareaccount.d.ts b/dist/cflare.classes.cflareaccount.d.ts index 3bb950e..897eb44 100644 --- a/dist/cflare.classes.cflareaccount.d.ts +++ b/dist/cflare.classes.cflareaccount.d.ts @@ -7,9 +7,11 @@ export declare class CflareAccount { email: string; key: string; }): void; + getZoneId(domainName: string): any; createRecord(): any; removeRecord(): any; + updateRecord(): void; listRecords(domainName: string): any; - listDomains(): any; - request(methodArg: string, routeArg: string): any; + listZones(domainName?: string): any; + request(methodArg: string, routeArg: string, bodyArg?: any): any; } diff --git a/dist/cflare.classes.cflareaccount.js b/dist/cflare.classes.cflareaccount.js index 7ad36ad..d581309 100644 --- a/dist/cflare.classes.cflareaccount.js +++ b/dist/cflare.classes.cflareaccount.js @@ -12,6 +12,23 @@ var CflareAccount = (function () { this.authEmail = optionsArg.email; this.authKey = optionsArg.key; }; + CflareAccount.prototype.getZoneId = function (domainName) { + var done = plugins.q.defer(); + this.listZones(domainName) + .then(function (responseArg) { + var filteredResponse = responseArg.result.filter(function (zoneArg) { + return zoneArg.name === domainName; + }); + if (filteredResponse.length >= 1) { + done.resolve(filteredResponse[0].id); + } + else { + plugins.beautylog.error("the domain " + domainName.blue + " does not appear to be in this account!"); + done.reject(undefined); + } + }); + return done.promise; + }; CflareAccount.prototype.createRecord = function () { var done = plugins.q.defer(); return done.promise; @@ -22,19 +39,36 @@ var CflareAccount = (function () { return done.promise; }; ; + CflareAccount.prototype.updateRecord = function () { + }; + ; CflareAccount.prototype.listRecords = function (domainName) { + var _this = this; var done = plugins.q.defer(); + this.getZoneId(domainName) + .then(function (domainIdArg) { + _this.request("GET", "/zones/" + domainIdArg + "/dns_records?per_page=100") + .then(function (responseArg) { + done.resolve(responseArg); + }); + }); return done.promise; }; - CflareAccount.prototype.listDomains = function () { + CflareAccount.prototype.listZones = function (domainName) { var done = plugins.q.defer(); - this.request("GET", "/zones") + var requestRoute = "/zones?per_page=50"; + if (domainName) + requestRoute = requestRoute + "&name=" + domainName; + var result = {}; + this.request("GET", requestRoute) .then(function (responseArg) { + result = responseArg; + done.resolve(result); }); return done.promise; }; ; - CflareAccount.prototype.request = function (methodArg, routeArg) { + CflareAccount.prototype.request = function (methodArg, routeArg, bodyArg) { var done = plugins.q.defer(); var options = { method: methodArg, @@ -43,7 +77,8 @@ var CflareAccount = (function () { "Content-Type": "application/json", "X-Auth-Email": this.authEmail, "X-Auth-Key": this.authKey - } + }, + json: bodyArg }; plugins.request(options, function (err, res, body) { if (!err && res.statusCode == 200) { @@ -64,4 +99,4 @@ var CflareAccount = (function () { exports.CflareAccount = CflareAccount; ; -//# sourceMappingURL=data:application/json;charset=utf8;base64,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 +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["cflare.classes.cflareaccount.ts"],"names":[],"mappings":"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","file":"cflare.classes.cflareaccount.js","sourcesContent":["/// <reference path=\"./typings/main.d.ts\" />\r\nimport plugins = require(\"./cflare.plugins\");\r\nimport helpers = require(\"./cflare.classes.helpers\");\r\n\r\nexport class CflareAccount {\r\n    private authEmail:string;\r\n    private authKey:string;\r\n    private authCheck(){\r\n        return (this.authEmail && this.authKey); //check if auth is available\r\n    }\r\n    constructor(){\r\n        \r\n    };\r\n    auth(optionsArg:{email:string,key:string}){\r\n        this.authEmail = optionsArg.email;\r\n        this.authKey = optionsArg.key;       \r\n    }\r\n    getZoneId(domainName:string){\r\n        let done = plugins.q.defer();\r\n        this.listZones(domainName)\r\n            .then((responseArg) => {\r\n                let filteredResponse = responseArg.result.filter((zoneArg)=>{\r\n                    return zoneArg.name === domainName;\r\n                });\r\n                if (filteredResponse.length >= 1){\r\n                    done.resolve(filteredResponse[0].id);\r\n                } else {\r\n                    plugins.beautylog.error(\"the domain \" + domainName.blue + \" does not appear to be in this account!\");\r\n                    done.reject(undefined);\r\n                }\r\n            });\r\n        return done.promise;\r\n    }\r\n    createRecord(){\r\n        let done = plugins.q.defer();\r\n        return done.promise;\r\n    };\r\n    removeRecord(){\r\n        let done = plugins.q.defer();\r\n        return done.promise;\r\n    };\r\n    updateRecord(){\r\n        \r\n    };\r\n    listRecords(domainName:string){\r\n        let done = plugins.q.defer();\r\n        this.getZoneId(domainName)\r\n            .then((domainIdArg)=>{\r\n                this.request(\"GET\",\"/zones/\" + domainIdArg + \"/dns_records?per_page=100\")\r\n                    .then(function(responseArg){\r\n                        done.resolve(responseArg);\r\n                    });\r\n            });\r\n        return done.promise;\r\n    }\r\n    listZones(domainName?:string){\r\n        let done = plugins.q.defer();\r\n        let requestRoute = \"/zones?per_page=50\"\r\n        if(domainName) requestRoute = requestRoute + \"&name=\" + domainName;\r\n        let result = {}; \r\n        this.request(\"GET\",requestRoute)\r\n            .then(function(responseArg){\r\n                result = responseArg;\r\n                done.resolve(result);\r\n            });\r\n        return done.promise;\r\n    };\r\n    request(methodArg:string,routeArg:string,bodyArg?){\r\n        let done = plugins.q.defer();\r\n        let options = {\r\n            method:methodArg,\r\n            url:\"https://api.cloudflare.com/client/v4\" + routeArg,\r\n            headers:{\r\n                \"Content-Type\":\"application/json\",\r\n                \"X-Auth-Email\":this.authEmail,\r\n                \"X-Auth-Key\":this.authKey\r\n            },\r\n            json:bodyArg\r\n        };\r\n        plugins.request(options,function(err, res, body){\r\n            if (!err && res.statusCode == 200) {\r\n                var responseObj = JSON.parse(body);\r\n                done.resolve(responseObj);\r\n            } else {\r\n                console.log(err);\r\n                console.log(res);\r\n                done.reject(err);\r\n            };\r\n        });\r\n        return done.promise;\r\n    }\r\n};"]} diff --git a/package.json b/package.json index abf13cb..3b480f4 100644 --- a/package.json +++ b/package.json @@ -26,6 +26,7 @@ "request": "^2.72.0" }, "devDependencies": { - "npmts": "^5.1.5" + "npmts": "^5.1.5", + "should": "^8.3.1" } } diff --git a/test/test.js b/test/test.js index 709f334..d6a27cf 100644 --- a/test/test.js +++ b/test/test.js @@ -1,11 +1,46 @@ "use strict"; /// var cflare = require("../dist/index"); +var should = require("should"); var nogit = require("../nogit/nogit.json"); var testCflareAccount = new cflare.CflareAccount(); testCflareAccount.auth({ email: nogit.cfemail, key: nogit.cfkey }); +describe("cflare", function () { + describe(".CflareAccount", function () { + describe(".listZones()", function () { + it("should display an account", function (done) { + this.timeout(10000); + testCflareAccount.listZones() + .then(function (responseArg) { + console.log(responseArg); + done(); + }); + }); + }); + describe(".getZoneId(domainName)", function () { + it("should get an Cloudflare Id for a domain string", function (done) { + this.timeout(5000); + testCflareAccount.getZoneId("push.rocks") + .then(function (responseArg) { + console.log(responseArg); + done(); + }); + }); + }); + describe(".listRecords(domainName)", function () { + it("should list all records for a specific Domain Name", function (done) { + this.timeout(5000); + testCflareAccount.listRecords("push.rocks") + .then(function (responseArg) { + console.log(responseArg); + done(); + }); + }); + }); + }); +}); -//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLGdEQUFnRDtBQUNoRCxJQUFPLE1BQU0sV0FBVyxlQUFlLENBQUMsQ0FBQztBQUN6QyxJQUFJLEtBQUssR0FBRyxPQUFPLENBQUMscUJBQXFCLENBQUMsQ0FBQztBQUUzQyxJQUFJLGlCQUFpQixHQUFHLElBQUksTUFBTSxDQUFDLGFBQWEsRUFBRSxDQUFDO0FBQ25ELGlCQUFpQixDQUFDLElBQUksQ0FBQztJQUNuQixLQUFLLEVBQUUsS0FBSyxDQUFDLE9BQU87SUFDcEIsR0FBRyxFQUFFLEtBQUssQ0FBQyxLQUFLO0NBQ25CLENBQUMsQ0FBQyIsImZpbGUiOiJ0ZXN0LmpzIiwic291cmNlc0NvbnRlbnQiOlsiLy8vIDxyZWZlcmVuY2UgcGF0aD1cIi4uL3RzL3R5cGluZ3MvbWFpbi5kLnRzXCIgLz5cclxuaW1wb3J0IGNmbGFyZSA9IHJlcXVpcmUoXCIuLi9kaXN0L2luZGV4XCIpO1xyXG5sZXQgbm9naXQgPSByZXF1aXJlKFwiLi4vbm9naXQvbm9naXQuanNvblwiKTtcclxuXHJcbmxldCB0ZXN0Q2ZsYXJlQWNjb3VudCA9IG5ldyBjZmxhcmUuQ2ZsYXJlQWNjb3VudCgpO1xyXG50ZXN0Q2ZsYXJlQWNjb3VudC5hdXRoKHtcclxuICAgIGVtYWlsOiBub2dpdC5jZmVtYWlsLFxyXG4gICAga2V5OiBub2dpdC5jZmtleVxyXG59KTtcclxuXHJcbiJdfQ== +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/test/test.ts b/test/test.ts index 3debc2f..6d36e8b 100644 --- a/test/test.ts +++ b/test/test.ts @@ -1,5 +1,6 @@ /// import cflare = require("../dist/index"); +let should = require("should"); let nogit = require("../nogit/nogit.json"); let testCflareAccount = new cflare.CflareAccount(); @@ -8,3 +9,37 @@ testCflareAccount.auth({ key: nogit.cfkey }); +describe("cflare",function(){ + describe(".CflareAccount",function(){ + describe(".listZones()",function(){ + it("should display an account",function(done){ + this.timeout(10000); + testCflareAccount.listZones() + .then((responseArg)=>{ + console.log(responseArg); + done(); + }) + }); + }); + describe(".getZoneId(domainName)",function(){ + it("should get an Cloudflare Id for a domain string",function(done){ + this.timeout(5000) + testCflareAccount.getZoneId("push.rocks") + .then((responseArg)=>{ + console.log(responseArg); + done(); + }); + }); + }); + describe(".listRecords(domainName)",function(){ + it("should list all records for a specific Domain Name",function(done){ + this.timeout(5000); + testCflareAccount.listRecords("push.rocks") + .then((responseArg) => { + console.log(responseArg); + done(); + }); + }); + }) + }) +}); diff --git a/ts/cflare.classes.cflareaccount.ts b/ts/cflare.classes.cflareaccount.ts index d992042..4ed5060 100644 --- a/ts/cflare.classes.cflareaccount.ts +++ b/ts/cflare.classes.cflareaccount.ts @@ -15,6 +15,32 @@ export class CflareAccount { this.authEmail = optionsArg.email; this.authKey = optionsArg.key; } + getZoneId(domainName:string){ + let done = plugins.q.defer(); + this.listZones(domainName) + .then((responseArg) => { + let filteredResponse = responseArg.result.filter((zoneArg)=>{ + return zoneArg.name === domainName; + }); + if (filteredResponse.length >= 1){ + done.resolve(filteredResponse[0].id); + } else { + plugins.beautylog.error("the domain " + domainName.blue + " does not appear to be in this account!"); + done.reject(undefined); + } + }); + return done.promise; + } + getRecord(domainNameArg:string,typeArg:string){ + let done = plugins.q.defer(); + this.listRecords(domainNameArg) + .then((responseArg) => { + let filteredResponse = responseArg.result.filter((recordArg) => { + return (recordArg.type == typeArg && recordArg.name == domainNameArg); + }) + }) + return done.promise; + }; createRecord(){ let done = plugins.q.defer(); return done.promise; @@ -23,20 +49,34 @@ export class CflareAccount { let done = plugins.q.defer(); return done.promise; }; + updateRecord(domainNameArg:string,typeArg:string,valueArg){ + let done = plugins.q.defer(); + return done.promise; + }; listRecords(domainName:string){ let done = plugins.q.defer(); - + this.getZoneId(domainName) + .then((domainIdArg)=>{ + this.request("GET","/zones/" + domainIdArg + "/dns_records?per_page=100") + .then(function(responseArg){ + done.resolve(responseArg); + }); + }); return done.promise; } - listDomains(){ + listZones(domainName?:string){ // TODO: handle pagination let done = plugins.q.defer(); - this.request("GET","/zones") + let requestRoute = "/zones?per_page=50" + if(domainName) requestRoute = requestRoute + "&name=" + domainName; + let result = {}; + this.request("GET",requestRoute) .then(function(responseArg){ - + result = responseArg; + done.resolve(result); }); return done.promise; }; - request(methodArg:string,routeArg:string){ + request(methodArg:string,routeArg:string,jsonArg?){ let done = plugins.q.defer(); let options = { method:methodArg, @@ -45,8 +85,9 @@ export class CflareAccount { "Content-Type":"application/json", "X-Auth-Email":this.authEmail, "X-Auth-Key":this.authKey - } - } + }, + json:jsonArg + }; plugins.request(options,function(err, res, body){ if (!err && res.statusCode == 200) { var responseObj = JSON.parse(body); diff --git a/ts/typings.json b/ts/typings.json index e66d896..8f505d5 100644 --- a/ts/typings.json +++ b/ts/typings.json @@ -3,6 +3,7 @@ "dependencies": {}, "ambientDependencies": { "colors": "registry:dt/colors#0.6.0-1+20160425153322", + "mocha": "registry:dt/mocha#2.2.5+20160317120654", "node": "registry:dt/node#4.0.0+20160423143914" } }