Strider-CD/strider

const base32 = require('thirty-two');
const crypto = require('crypto');
const debug = require('debug')('strider:routes:admin');
const humane = require('../../utils/humane');
const InviteCode = require('../../models').InviteCode;
const Job = require('../../models').Job;
const pjson = require('../../../package.json');
const Project = require('../../models').Project;
const projects = require('../../projects');
const Step = require('step');
const User = require('../../models').User;
const users = require('../../users');
const utils = require('../../utils');
/*
 * makeInviteCode()
 *
 * Generate a sweet BASE32 invite code
 */
function makeInviteCode() {
    const random = crypto.randomBytes(5).toString('hex');
    return base32.encode(random);
}
/*
 * GET /admin/invites - admin interface for invites
 */
exports.invites = function (req, res) {
    InviteCode.find({})
        .populate('consumed_by_user')
        .sort({ _id: -1 })
        .exec(function (err, results) {
        results.forEach(function (invite) {
            invite.created = humane.humaneDate(invite.created_timestamp);
            invite.consumed = humane.humaneDate(invite.consumed_timestamp);
        });
        res.render('admin/invites.html', {
            invite_code: makeInviteCode(),
            invite_codes: results,
            version: pjson.version,
            csrfToken: req.csrfToken()
        });
    });
};
/*
 * GET /admin/users - admin interface for users
 */
exports.users = function (req, res) {
    User.find({})
        .sort({ _id: -1 })
        .exec(function (err, users) {
        res.render('admin/users.html', {
            flash: req.flash('admin'),
            version: pjson.version,
            users: users.map(function (user) {
                user.created_date = humane.humaneDate(utils.timeFromId(user.id));
                return user;
            }),
            csrfToken: req.csrfToken()
        });
    });
};
exports.makeAdmin = function (req, res) {
    if (!req.body.user) {
        return res.redirect('/admin/users');
    }
    users.makeAdmin(req.body.user, function (err) {
        if (err) {
            debug(err);
            return res.send(500, 'Error making admin user');
        }
        res.redirect('/admin/users');
    });
};
exports.removeUser = function (req, res) {
    User.findOne({ email: req.body.email }, function (err, user) {
        if (err || !user) {
            req.flash('admin', 'Failed to find user');
            return res.redirect('/admin/users');
        }
        Project.collection.remove({
            creator: user._id,
        }, function (err, number) {
            if (err)
                req.flash('admin', 'Failed to remove projects');
            req.flash('admin', `Removed ${number} projects owned by ${user.email}`);
            user.remove(function (err) {
                if (err)
                    req.flash('admin', 'Failed to remove user');
                res.redirect('/admin/users');
            });
        });
    });
};
/*
 * GET /admin/projects - admin interface for projects
 */
exports.projects = function (req, res) {
    projects.allProjects(function (err, projects) {
        if (err)
            return res.send(500, 'Error retrieving projects');
        res.render('admin/projects.html', {
            projects: projects,
            version: pjson.version,
        });
    });
};
/*
 * GET /admin/plugins
 * PUT /admin/plugins/:id */
exports.plugins = require('./plugins');
// XXX: what are we trying to do here??? - jaredly
/*
 * index.admin_job - build the admin job detail page
 * this is very similar although slightly different from the job function above.
 * at some point they should be refactored to combine redundant func.
 */
exports.job = function (req, res) {
    res.statusCode = 200;
    const org = req.params.org;
    const repo = req.params.repo;
    const jobId = req.params.job_id;
    let repoUrl = `https://github.com/${org}/${repo}`;
    repoUrl = repoUrl.toLowerCase();
    Step(function runQueries() {
        debug(`Querying for job id: ${jobId}`);
        Job.findById(jobId).populate('_owner').exec(this.parallel());
        debug(`Querying for last 20 jobs for ${repoUrl}`);
        Job.find()
            .sort({ finished_timestamp: -1 })
            .where('finished_timestamp')
            .ne(null)
            .where('repo_url', repoUrl)
            .where('type')
            .in(['TEST_ONLY', 'TEST_AND_DEPLOY'])
            .limit(20)
            .populate('_owner')
            .exec(this.parallel());
    }, function processAndRender(err, resultsDetail, results) {
        if (err)
            throw err;
        results.forEach(function (job) {
            job.duration = Math.round((job.finished_timestamp - job.created_timestamp) / 1000);
            job.finished_at = humane.humaneDate(job.finished_timestamp);
            if (job.github_commit_info.id !== undefined) {
                job.triggered_by_commit = true;
                job.gravatar_url = utils.gravatar(job.github_commit_info.author.email);
                if (job.github_commit_info.author.username !== undefined) {
                    job.committer = job.github_commit_info.author.username;
                    job.committer_is_username = true;
                }
                else {
                    job.committer = job.github_commit_info.author.name;
                    job.committer_is_username = false;
                }
            }
            job.url = `/admin/${org}/${repo}/job/${job.id}`;
        });
        // if resultsDetail did not return, that means this is not a valid job id
        if (resultsDetail === undefined) {
            res.render(404, 'invalid job id');
        }
        else {
            resultsDetail.duration = Math.round((resultsDetail.finished_timestamp - resultsDetail.created_timestamp) /
                1000);
            resultsDetail.finished_at = humane.humaneDate(resultsDetail.finished_timestamp);
            let triggeredByCommit = false;
            if (resultsDetail.github_commit_info.id !== undefined) {
                triggeredByCommit = true;
                resultsDetail.gravatar_url = utils.gravatar(resultsDetail.github_commit_info.author.email);
                if (resultsDetail.github_commit_info.author.username !== undefined) {
                    resultsDetail.committer =
                        resultsDetail.github_commit_info.author.username;
                    resultsDetail.committer_is_username = true;
                }
                else {
                    resultsDetail.committer =
                        resultsDetail.github_commit_info.author.name;
                    resultsDetail.committer_is_username = false;
                }
            }
            resultsDetail.output = resultsDetail.stdmerged.replace(/\[(\d)?\d*m/gi, '');
            const hasProdDeployTarget = false;
            const adminView = true;
            res.render('job.html', {
                admin_view: adminView,
                jobs: results,
                results_detail: resultsDetail,
                job_id: results[0].id.substr(0, 8),
                triggered_by_commit: triggeredByCommit,
                org: org,
                repo: repo,
                repo_url: repoUrl,
                has_prod_deploy_target: hasProdDeployTarget,
                version: pjson.version,
            });
        }
    });
};
//# sourceMappingURL=index.js.map