add archives api

src/routes/apps.js

@@ -185,6 +185,8 @@ async function install(req, res, next) {
 
     if ('enableTurn' in data && typeof data.enableTurn !== 'boolean') return next(new HttpError(400, 'enableTurn must be boolean'));
 
+    if ('backupId' in data && typeof data.backupId !== 'string') return next(new HttpError(400, 'backupId must be non-empty string'));
+
     let [error, result] = await safe(appstore.downloadManifest(data.appStoreId, data.manifest));
     if (error) return next(BoxError.toHttpError(error));
 

src/routes/archives.js

@@ -0,0 +1,57 @@
+'use strict';
+
+exports = module.exports = {
+    load,
+
+    list,
+    get,
+    del
+};
+
+const assert = require('assert'),
+    { archives } = require('../backups.js'),
+    AuditSource = require('../auditsource.js'),
+    BoxError = require('../boxerror.js'),
+    HttpError = require('connect-lastmile').HttpError,
+    HttpSuccess = require('connect-lastmile').HttpSuccess,
+    safe = require('safetydance');
+
+async function load(req, res, next) {
+    assert.strictEqual(typeof req.params.id, 'string');
+
+    const [error, result] = await safe(archives.get(req.params.id));
+    if (error) return next(BoxError.toHttpError(error));
+    if (!result) return next(new HttpError(404, 'Backup not found'));
+
+    req.resource = result;
+
+    next();
+}
+
+async function list(req, res, next) {
+    const page = typeof req.query.page !== 'undefined' ? parseInt(req.query.page) : 1;
+    if (!page || page < 0) return next(new HttpError(400, 'page query param has to be a postive number'));
+
+    const perPage = typeof req.query.per_page !== 'undefined'? parseInt(req.query.per_page) : 25;
+    if (!perPage || perPage < 0) return next(new HttpError(400, 'per_page query param has to be a postive number'));
+
+    const [error, result] = await safe(archives.list(page, perPage));
+    if (error) return next(BoxError.toHttpError(error));
+
+    next(new HttpSuccess(200, { archives: result }));
+}
+
+async function get(req, res, next) {
+    assert.strictEqual(typeof req.params.id, 'string');
+
+    next(new HttpSuccess(200, req.resource));
+}
+
+async function del(req, res, next) {
+    assert.strictEqual(typeof req.params.id, 'string');
+
+    const [error] = await safe(archives.del(req.resource.id, AuditSource.fromRequest(req)));
+    if (error) return next(BoxError.toHttpError(error));
+
+    next(new HttpSuccess(204));
+}

src/routes/index.js

@@ -6,6 +6,7 @@ exports = module.exports = {
     apps: require('./apps.js'),
     applinks: require('./applinks.js'),
     appstore: require('./appstore.js'),
+    archives: require('./archives.js'),
     auth: require('./auth.js'),
     backups: require('./backups.js'),
     branding: require('./branding.js'),

src/routes/test/archives-test.js

@@ -0,0 +1,81 @@
+/* global it:false */
+/* global describe:false */
+/* global before:false */
+/* global after:false */
+
+'use strict';
+
+const backups = require('../../backups.js'),
+    common = require('./common.js'),
+    expect = require('expect.js'),
+    superagent = require('superagent');
+
+describe('Archives API', function () {
+    const { setup, cleanup, serverUrl, owner } = common;
+
+    const nonArchiveBackup = {
+        id: null,
+        remotePath: 'app_appid_123',
+        encryptionVersion: null,
+        packageVersion: '1.0.0',
+        type: backups.BACKUP_TYPE_APP,
+        state: backups.BACKUP_STATE_CREATING,
+        identifier: 'appid',
+        dependsOn: [ ],
+        manifest: { foo: 'bar' },
+        format: 'tgz',
+        preserveSecs: 0,
+        label: '',
+        archive: false
+    };
+
+    const archiveBackup = Object.assign({}, nonArchiveBackup, {archive: true, remotePath: 'app_appid_234'});
+
+    before(async function () {
+        await setup();
+        nonArchiveBackup.id = await backups.add(nonArchiveBackup);
+        archiveBackup.id = await backups.add(archiveBackup);
+        await backups.update(archiveBackup.id, { archive: true });
+    });
+    after(cleanup);
+
+    it('list succeeds', async function () {
+        const response = await superagent.get(`${serverUrl}/api/v1/archives`)
+            .query({ access_token: owner.token });
+        expect(response.statusCode).to.equal(200);
+        expect(response.body.archives.length).to.be(1);
+        expect(response.body.archives[0].id).to.be(archiveBackup.id);
+    });
+
+    it('get valid archive', async function () {
+        const response = await superagent.get(`${serverUrl}/api/v1/archives/${archiveBackup.id}`)
+            .query({ access_token: owner.token });
+        expect(response.statusCode).to.equal(200);
+        expect(response.body.remotePath).to.be('app_appid_234');
+    });
+
+    it('cannot get invalid archive', async function () {
+        const response = await superagent.get(`${serverUrl}/api/v1/archives/random`)
+            .query({ access_token: owner.token })
+            .ok(() => true);
+        expect(response.statusCode).to.equal(404);
+    });
+
+    it('cannot del invalid archive', async function () {
+        const response = await superagent.del(`${serverUrl}/api/v1/archives/${nonArchiveBackup.id}`)
+            .query({ access_token: owner.token })
+            .ok(() => true);
+        expect(response.statusCode).to.equal(404);
+    });
+
+    it('del valid archive', async function () {
+        const response = await superagent.del(`${serverUrl}/api/v1/archives/${archiveBackup.id}`)
+            .query({ access_token: owner.token });
+        expect(response.statusCode).to.equal(204);
+
+        const response2 = await superagent.get(`${serverUrl}/api/v1/archives`)
+            .query({ access_token: owner.token });
+        expect(response2.statusCode).to.equal(200);
+        expect(response2.body.archives.length).to.be(0);
+    });
+});