walnut_launchpad.html/js/controllers/website-controller.js

(function () {
'use strict';

var app = window.app;
//
// Angular file upload hack
//
// TODO modularize for reuse
function analyzeFile(file, vm) {
  vm.triggerFileRefresh = 'changed';
  vm.isZip = /\.zip$/.test(file.name);
  vm.unzip = vm.isZip;
  vm.stripZip = vm.isZip;
  return vm;
}

/*
function handleFiles(ev) {
  var selector = 'js-file-upload';
  var $scope;
  var vm;

  if ('INPUT' !== ev.target.tagName || 'file' !== ev.target.type || -1 === ev.target.className.indexOf(selector)) {
    return;
  }

  $scope = angular.element(ev.target).scope();
  // 'vm' is the Controller As name.
  vm = $scope.vm;
  vm.currentFiles = ev.target.files;
  analyzeFile(vm.currentFiles[0], vm);

  $scope.$digest();
  console.log('[handleFiles] vm.currentFiles:');
  console.log(vm.currentFiles);
}
window.document.body.addEventListener('change', handleFiles);
*/

app.directive('daplieFileChange', [function () {
  return {
    restrict: 'A',
    require:"ngModel",
    link: function (scope, element, attrs, ngModel) {
      element.bind('change', function (event) {
        var files = event.target.files;
        ngModel.$setViewValue(files[0]);
        scope.$eval(attrs.daplieFileChange);
      });
    }
  };
}]);

app.directive('fileTree', [function () {
  return {
    restrict: 'EA',
    templateUrl: '/templates/widgets/filetree.html',
    controller: 'websiteCtrl as vm'
  };
}]);

app.directive('notificationBar', [function () {
  return {
    restrict: 'EA',
    templateUrl: '/templates/widgets/website-notification-bar.html',
    controller: 'websiteCtrl as vm'
  };
}]);

app.controller('websiteCtrl', [
  '$scope', '$q', 'Auth', 'azp@oauth3.org', '$timeout', '$sce'
, function ($scope, $q, Auth, Oauth3, $timeout, $sce) {

  var vm = this;
  var angular = window.angular;
  vm.domains = [];
  vm.copyUploadPath = '';
  vm.displaySpinner = '';
  vm.deleteAll = '';
  vm.alertNotification = {
    hidden: 'hidden'
  };
  //vm.unzipPath = '/';
  vm.uploadPath = '/';


  // already validated
  function domainIsVerified(r) {
    return r.verifiedAt || r.mode;
  }

  Auth.api = function (apiname, opts) {
    var els = [];

    return $q.all(Auth.sessions.map(function (session) {

      return Auth.get(session).then(function (oauth3) {

        return oauth3.api(apiname, {}).then(function (collection) {

          if (collection.error) {
            // not all tokens support all apis
            return;
          }

          if (!Array.isArray(collection)) {
            console.error('collection is not an array');
            console.error(collection);
            return;
          }

          collection.forEach(function (el) {
            els.push(el);
            el.session = session.token.sub + '@' + session.token.iss;
          });

        });
      });
    })).then(function (results) {
      return els;
    });
  };

  vm.getDomains = function () {
    return Auth.oauth3.api('domains.list', {}).then(function (result) {
      vm.domains = result.registrations || result;
    });
  };

  vm.setDomain = function () {
    if (!vm.domains || !vm.domains.length) {
      vm.domain = { domain: vm.newDomain };
      return;
    }

    vm.domains.some(function (domain) {
      if (domain.domain === vm.newDomain) {
        vm.domain = domain;
        return true;
      }
    });

    if (!vm.domain) {
      vm.domain = { domain: vm.newDomain };
    }

    if (!vm.domain.tld) {
      var parts = vm.domain.domain.split('.');
      vm.domain.sld = parts.shift();
      vm.domain.tld = parts.join('.');
    }

    vm.setRecord();
  };

  vm.selectDomain = function (domain) {
    vm.domain = domain; //vm.selectedDomain.description;
    vm.newDomain = vm.domain.domain;

    return Auth.api('dns.list', { }).then(function (records) {
      records = records.filter(function (r) {
        return /^A(AAA)?$/i.test(r.type) && ((r.sld + '.' + r.tld) === vm.domain.domain || r.zone === vm.domain.domain);
      });
      vm.records = records;
      records.forEach(function (record) {
        if (!record.sub) {
          record.sub = record.host.replace('.' + record.zone, '');
          if (record.host === record.zone) {
            record.sub = '@';
          }
        }
      });
      console.log('[selectDomain] dns records:');
      console.log(records);
    });
  };

  vm.setRecord = function () {
    // TODO set record based on (record.host === sub + domain.domain)
    var sub = vm.newRecord;

    if ('@' === sub) {
      sub = '';
    }
    vm.record = { sub: sub, host: (sub ? sub + '.' : '') + vm.domain.domain };
    vm.currentHost = vm.record.host;

    console.log('[setRecord] vm.record:');
    console.log(vm.record);
  };

  vm.selectRecord = function (record) {
    vm.record = record;
    vm.newRecord = record.sub;
    vm.currentHost = record.host; // .replace(new RegExp('\\.' + vm.domain.domain.replace(/\./g, '\\.') + '$', ''));
  };

  vm._uploadFileVm = function (pkg, opts) {
    return vm._uploadFile(pkg, {
      domain: opts.currentHost
    , tld: opts.domain.tld
    , sld: opts.domain.sld
    , sub: opts.domain.sub
    , newFile: opts.newFile
    , uploadPath: opts.uploadPath
    , progress: opts
    });
  };
  vm._uploadFile = function (pkg, opts) {
    debugger;
    vm.newFileUploaded = opts.newFile.name;
    opts.progress = opts.progress || opts;
    return pkg.add({
      hostname: opts.domain
    , domain: opts.domain
    , tld: opts.tld
    , sld: opts.sld
    //, sub: opts.record.sub
    , multipart: { site: opts.newFile }
    , progress: function (ev) {
        // TODO must digest
        opts.progress.uploadPercent = Math.round((ev.loaded / ev.total) * 100);
        // TODO GiB, MiB, KiB, etc
        opts.progress.uploadTotal = (ev.total / (1024 * 1024)).toFixed(2);
        opts.progress.uploadProgress = (ev.loaded / (1024 * 1024)).toFixed(2);
      }
    , unzip: opts.unzip
    , strip: opts.stripZip
    , path: opts.uploadPath
    }).then(function (result) {
      var msg = vm.newFileUploaded + " has been uploaded"
      opts.progress.uploadTotal = 0;
      vm.buildNotification(result, msg);
      // window.alert(JSON.stringify(result));
    });
  };

  vm._isSubDomain = function (sub, domain) {
    return -1 !== ('.' + sub).indexOf(('.' + domain));
  };

  vm.Sites = {};
  vm.Sites.create = function () {
    var pkg = Auth.oauth3.pkg('www@daplie.com');
    var parts;
    var sub;
    var sld;
    var tld;

    /*
    //vm.unlock('webpreneur');
    if (!vm.currentFiles || !vm.currentFiles.length) {
      window.alert('No files chosen.');
      return;
    }
    if (1 !== vm.currentFiles.length) {
      window.alert('Too many files chosen.');
      return;
    }
    */
    if (!vm.newFile) {
      window.alert('No file chosen.');
      return;
    }
    if (!vm.currentHost) {
      window.alert('No hostname chosen.');
      return;
    }

    if (vm.domain) {
      if (!vm.domain.tld || !vm.domain.sld) {
        parts = vm.domain.domain.split('.');
        sld = parts.shift();
        tld = parts.join('.');
      } else {
        sld = vm.domain.sld;
        tld = vm.domain.tld;
      }
    } else {
      parts = vm.currentHost.split('.');
      // TODO get list of tlds
      tld = parts.pop();
      sld = parts.pop();
      sub = parts.join('.');
    }

    if (vm.sites.some(function (r) {
      return (-1 !== ('.' + vm.currentHost).indexOf(('.' + r.domain))) && domainIsVerified(r);
    })) {
      vm._uploadFileVm(pkg, vm);
      return;
    }

    // We're making a request to claim a domain
    // (because two users could both claim a single domain)
    // We're claiming it at the top level (i.e. example.com)
    // but we could also claim it at the subdomain level (needs UI update)
    var domainReq = { sld: sld, tld: tld, sub: undefined };
    return pkg.request(domainReq).then(function (result) {
      var sess;
      var prom;
      var def;

      // can validate automatically
      if (vm.domain.session && vm._isSubDomain(vm.currentHost, vm.domain.domain)) {
        // this should always succeed
        Auth.sessions.some(function (session) {
          if (vm.domain.session === (session.token.sub + '@' + session.token.iss)) {
            sess = session;
            return session;
          }
        });

        if (sess) {
          prom = Auth.get(sess).then(function (oauth3) {
            return oauth3.api('dns.set', { sld: sld, tld: tld, sub: ('' + result.data.prefix), type: 'TXT', ttl: 300, value: result.data.challenge });
          });
        }
      }

      if (!prom) {
        def = $q.defer();
        // must validate manually
        window.alert(
          "Please set a TXT record for '"
        + ('' + result.data.prefix) + '.' + sld + '.' + tld
        + "' with the value '" + result.data.challenge + "' and then continue."
        );
        def.resolve();
        prom = def.promise;
      }

      return prom.then(function () {
        return pkg.claim(domainReq).then(function (result) {
          return vm._uploadFileVm(pkg, vm);
        });
      });

    });
  };

  vm.Sites.setUpload = function (r) {
    console.log("Hey! At least it can tell if there's a change!");
    analyzeFile(r.newFile, r);
    console.log(r);
  };


  vm.breadcrumbs = [];
  vm.breadcrumbsPath = [''];
  vm.siteDirectories = [];
  vm.siteFiles = [];
  vm.Sites.allContents = function (r) {
    vm.copyR = r;
    vm.strictPath = r.shareAccess.path;
    var pkg = Auth.oauth3.pkg('www@daplie.com');
    return pkg.contents({
      hostname: r.domain
    , domain: r.domain
    , tld: r.tld
    , sld: r.sld
    //, sub: r.sub
    , path: r.shareAccess.path
    }).then(function (result) {
      if (r.shareAccess.path !== '/') {
        var strictPathName = r.shareAccess.path.split('/');
        strictPathName = strictPathName[strictPathName.length - 2];
        vm.breadcrumbs.push(strictPathName);
      } else {
        vm.breadcrumbs.push('root');
      }
      vm.folderStructure = result;
      result.data.forEach(function(data){
        if (data.file) {
          vm.siteFiles.push(data.name);
        }
        if (data.directory) {
          vm.siteDirectories.push(data.name);
        }
      });
      vm.displaySpinner = 'hidden';
      // window.alert(JSON.stringify(result));
    });
  };

  vm.Sites.contents = function (r, dir) {
    vm.displaySpinner = '';
    var pkg = Auth.oauth3.pkg('www@daplie.com');
    return pkg.contents({
      hostname: r.domain
    , domain: r.domain
    , tld: r.tld
    , sld: r.sld
    //, sub: r.sub
    , path: dir
    }).then(function (result) {
      vm.displaySpinner = 'hidden';
      vm.siteFiles = [];
      vm.siteDirectories = [];
      vm.folderStructure = result;
      result.data.forEach(function(data){
        if (data.file) {
          vm.siteFiles.push(data.name);
        }
        if (data.directory) {
          vm.siteDirectories.push(data.name);
        }
      });
      // window.alert(JSON.stringify(result));
    });
  };

  vm.getDirectoriesFromBreadcrumbs = function (dir) {
    if (vm.copyR.shareAccess.path !== '/') {
      var arry = vm.breadcrumbsPath.split('/');
      arry.pop();
      var removeFromBreadcrumbs = arry.indexOf(dir) + 1;
      var newArry = vm.breadcrumbs;
      newArry.pop();
      vm.breadcrumbsPath = arry.splice(0,removeFromBreadcrumbs);
      vm.breadcrumbs = vm.breadcrumbs.splice(0,removeFromBreadcrumbs);
      vm.Sites.contents(vm.copyR, vm.breadcrumbsPath.join('/'));
    } else {
      vm.breadcrumbsPath.unshift('');
      var removeFromBreadcrumbs = vm.breadcrumbsPath.indexOf(dir) + 1;
      vm.breadcrumbsPath = vm.breadcrumbsPath.splice(0,removeFromBreadcrumbs);
      vm.breadcrumbs = vm.breadcrumbs.splice(0,removeFromBreadcrumbs);
      vm.Sites.contents(vm.copyR, vm.breadcrumbsPath.join('/'));
      if (dir === 'root') {
        vm.breadcrumbs = ['root'];
        vm.breadcrumbsPath = [];
      }
    }
  };

  vm.getDirectories = function (dir) {
    if (vm.copyR.shareAccess.path !== '/') {
      vm.breadcrumbs.push(dir);
      vm.breadcrumbsPath = vm.copyR.shareAccess.path + dir + '/';
      vm.Sites.contents(vm.copyR, vm.breadcrumbsPath);
    } else {
      vm.breadcrumbs.push(dir);
      vm.breadcrumbsPath.push(dir);
      vm.Sites.contents(vm.copyR, vm.breadcrumbsPath.join('/'));
    }
  };

  vm.removeAllFiles = function (r, opts) {
    console.log(r);
    console.log(opts);
    opts = {
      path: '/',
      confirm: true
    };
    vm.Sites.remove(r, opts);
  };

  vm.deleteFilesFrom = function (r, opts) {
    var file = opts;
    var requestedPath = vm.breadcrumbsPath.join('/') + '/' + file;
    opts = {
      path: requestedPath
    };
    vm.Sites.remove(r, opts);
  };

  vm.Sites.remove = function (r, opts) {
    if (!window.confirm("Delete files for this site?")) {
      return;
    }
    var pkg = Auth.oauth3.pkg('www@daplie.com');
    return pkg.remove({
      hostname: r.domain,
      domain: r.domain,
      tld: r.tld,
      sld: r.sld,
      // sub: vm.record.sub,
      path: opts.path || r.path,
      confirm: opts.confirm || r.confirm
    }).then(function (result) {
      var msg = "'"+ vm.pathRemoved + "'" + ' has been removed';
      vm.buildNotification(result, msg);
      window.alert(JSON.stringify(result));
    });
  };

  vm.Sites.archive = function (r) {
    var pkg = Auth.oauth3.pkg('www@daplie.com');
    return pkg.archive({
      hostname: r.domain
    , domain: r.domain
    , tld: r.tld
    , sld: r.sld
    //, sub: vm.record.sub
    //, path: vm.uploadPath
    }).then(function (result) {
      window.alert(JSON.stringify(result));
      // TODO use iframe to initiate download?
      window.open(result.data.url);
    });
  };

  vm.doSomething = function (r) {
    window.alert("Fix me");
  };

  vm.shareFolderFrom = function (r, opts) {
    var sharePath;
    if (vm.breadcrumbsPath.join('/') === '' && vm.breadcrumbs.join('/') === '') {
      sharePath = '/';
    } else {
      sharePath = vm.breadcrumbsPath.join('/');
    }
    // FIXME: shareMode may be broken
    opts = {
      sharePath: sharePath,
      shareMode: ''
    };
    vm.Shares.invite(r, opts);
  };

  vm.createNewFolder = function (r) {
    if (r.shareAccess.path !== '/') {
      vm.breadcrumbsPath;
      vm.breadcrumbs;
      r.folderName = vm.breadcrumbsPath + vm.folderName;
      debugger;
    } else {
      if (vm.breadcrumbsPath.join('/') === '') {
        r.folderName = '/' + vm.folderName + '/';
      } else {
        r.folderName = vm.breadcrumbsPath.join('/') + '/' + vm.folderName + '/';
      }
    }
  };

  vm.Sites.upload = function (r) {
    var pkg = Auth.oauth3.pkg('www@daplie.com');
    //analyzeFile(r.newFile, r);
    if (r.folderName !== '' && r.folderName !== undefined) {
      r.uploadPath = r.folderName;
    } else {
      if (vm.breadcrumbsPath.join('/') === '') {
        r.uploadPath = '/';
      } else {
        r.uploadPath = vm.breadcrumbsPath.join('/') + '/';
      }
    }
    vm._uploadFile(pkg, r);
  };

  vm.Shares = {};
  vm.Shares.invite = function (r, opts) {
    var pkg = Auth.oauth3.pkg('www@daplie.com');
    return pkg.invite({
      comment: r.shareEmail
    , email: r.shareEmail
    , domain: r.domain
    , tld: r.tld
    , sld: r.sld
    //, sub: r.sub
    , path: opts.sharePath || r.sharePath
    , mode: opts.shareMode || r.shareMode
    }).then(function (result) {
      var arr = r.sharedWith || [];
      arr.push(result.data);
      r.sharedWith = arr;
      window.alert(JSON.stringify(result.data));
    });
  };

  vm.Shares.accept = function () {
    var pkg = Auth.oauth3.pkg('www@daplie.com');
    return pkg.acceptInvite({
      token: vm.Shares.inviteToken
    }).then(function (result) {
      window.alert(JSON.stringify(result));
      vm.listSites();
    });
  };

  vm.Shares.list = function (r) {
    var pkg = Auth.oauth3.pkg('www@daplie.com');
    return pkg.listShares({
      domain: r.domain
    , hostname: r.domain
    , tld: r.tld
    , sld: r.sld
    //, sub: r.sub
    , path: r.sharePath
    }).then(function (result) {
      if (result.data.length === 0) {
        vm.notSharedMessage = "Currently not shared...";
      }
      vm.displaySpinner = 'hidden';
      console.log('list shares result:');
      console.log(result);
      r.sharedWith = result.data;
      //r.usersnames = r.sharedWith.map().join(',');
    });
  };

  vm.Shares.remove = function (r, s) {
    console.log('Shares.remove');
    var pkg = Auth.oauth3.pkg('www@daplie.com');
    return pkg.removeShare({
      domain: s.domain
    , hostname: s.domain
    , tld: s.tld
    , sld: s.sld
    //, sub: r.sub
    , path: s.sharePath
    , challenge: s.challenge
    }).then(function (result) {
      var person = result.data.comment;
      var msg = "revoked access from " + person;
      vm.buildNotification(result, msg);
      console.log('remove share result:');
      console.log(result);
      var index;

      r.sharedWith.forEach(function (_s, i) {
        if (s.challenge === _s.challenge) {
          index = i;
        }
      });

      r.sharedWith.splice(index, 1);
      //r.usersnames = r.sharedWith.map().join(',');
    });
  };

  vm.listSites = function () {
    var sites = [];

    return $q.all(Auth.sessions.map(function (session) {

      return Auth.get(session).then(function (oauth3) {
        var pkg = oauth3.pkg('www@daplie.com');

        return pkg.list().then(function (result) {
          var _sites = result.data;

          if (Array.isArray(_sites)) {
            sites = _sites.concat(sites);
            return;
          }
          // console.error('_sites is not an array');
          // console.error(_sites);
        }, function (err) {
          console.error('_sites had an error');
          console.error(err);
        });
      });
    })).then(function () {
      sites.forEach(function (site) {
        site.pending = !domainIsVerified(site);
      });
      // console.log('[listSites] sites:');
      // console.log(sites);
      vm.sites = sites;
      vm.sites.forEach(function(site) {
        site.urlSafeDomain = "https://" + site.domain;
        site.urlSafeDomain = $sce.trustAsResourceUrl(site.urlSafeDomain);
      });
    });
  };

  //vm.getDomains();
  Auth.api('domains.list', {}).then(function (els) {
    // console.log('[init] domains.list els:');
    // console.log(els);
    vm.domains = els;
    $scope.domain = vm.domains;
  });
  vm.listSites();

  vm.triggerDropdown = function() {
    $timeout(function() {
      var el = document.querySelector('.trigger-dropdown');
      angular.element(el).triggerHandler('focus');
    }, 0);
  };

  vm.cleanArrays = function () {
    vm.breadcrumbsPath = [];
    vm.breadcrumbs = [];
    vm.siteFiles = [];
    vm.siteDirectories = [];
  };

  vm.checkShareRights = function (r) {
    if (r.invitedBy) {
      r.shareAccess = { write: false, read: false, invite: false };
      if (r.mode.includes('w')) {
        r.shareAccess.write = true;
      }
      if (r.mode.includes('r')) {
        r.shareAccess.read = true;
      }
      if (r.mode.includes('x')) {
        r.shareAccess.invite = true;
      }
      r.shareAccess.path = r.path;
      console.log(r.shareAccess);
    } else {
      r.shareAccess = { write: true, read: true, invite: true, path: '/' };
    }
  };


  $scope.$watch('vm.selectedDomain', function (domainSelected) {
    if (domainSelected !== undefined) {
      vm.dom = domainSelected.description;
      vm.selectDomain(vm.selectedDomain.description);
    }
  });

  $scope.$watch('selectedAccess', function (selectedAccess) {
    if (selectedAccess.length !== 0) {
      vm.accessLevelArry = [];
      vm.prettyAccessArray = [];
      selectedAccess.forEach(function(letter) {
        vm.prettyAccessArray.push(letter.name);
        vm.accessLevelArry.push(letter.value);
      });
      vm.prettyShareMode = vm.prettyAccessArray.join(", ");
      vm.copiedShareMode = vm.accessLevelArry.join(",");
    }
  });

  $scope.selectedAccess = [];
  $scope.accessLevel = [{ name: 'Read', value: 'r' }, { name: 'Write', value: 'w' }, { name: 'Invite', value: 'x' }];

  $scope.localDomainSearch = function(str, domain) {
    var matches = [];
    domain.forEach(function(domain) {
      if ((domain.domain.toLowerCase().indexOf(str.toString().toLowerCase()) >= 0)) {
        matches.push(domain);
      }
    });
    return matches;
  };

  vm.showAction = function (action) {
    switch(action) {
      case 'invite':
        vm.showInviteContainer = true;
        vm.websiteTiles = true;
        vm.showBackBtn = true;
        vm.displayFileTree = true;
        if (vm.currentFolder === undefined || vm.currentFolder === 'hidden' || vm.currentFolder === 'root') {
          vm.currentFolder = 'All Folders/Files';
        }
      break;
      case 'shares':
        vm.showSharesContainer = true;
        vm.websiteTiles = true;
        vm.showBackBtn = true;
      break;
      case 'files':
        vm.showFilesContainer = true;
        vm.websiteTiles = true;
        vm.showBackBtn = true;
      break;
      default:
    }
  };

  vm.buildNotification = function (result, msg) {
    if (result.data.error) {
      vm.alertNotification = {
        className: 'danger',
        title: 'Error',
        hidden: '',
        message: msg
      };
    } else {
      vm.alertNotification = {
        className: 'success',
        title: 'Success',
        hidden: '',
        message: msg
      };
    }
  };

  vm.closeAllOpenActions = function () {
    $timeout(function() {
      vm.showInviteContainer = false;
      vm.showSharesContainer = false;
      vm.showFilesContainer = false;
      vm.displayFileTree = false;
      vm.websiteTiles = false;
      vm.showBackBtn = false;
      vm.autoPopulateWebPath = '';
    }, 150);
  };
}]);

}());

app.filter('stringify', function() {
  function getSerialize (fn, decycle) {
    var seen = [], keys = [];
    decycle = decycle || function(key, value) {
    return '[Parent REFERENCE]: ' + value.id;
    };
    return function(key, value) {
      var ret = value;
      if (typeof value === 'object' && value) {
        if (seen.indexOf(value) !== -1)
          ret = decycle(key, value);
        else {
          seen.push(value);
          keys.push(key);
        }
      }
      if (fn) ret = fn(key, ret);
      return ret;
    };
  }
  function getPath (value, seen, keys) {
    var index = seen.indexOf(value);
    var path = [ keys[index] ];
    for (index--; index >= 0; index--) {
      if (seen[index][ path[0] ] === value) {
        value = seen[index];
        path.unshift(keys[index]);
      }
    }
    return '~' + path.join('.');
  }
  function stringify(obj, fn, spaces, decycle) {
    return JSON.stringify(obj, getSerialize(fn, decycle), spaces);
  }
  stringify.getSerialize = getSerialize;
  return function(ob) {
    return stringify(ob, undefined, 2);
  };
});

app.filter('capitalize', function() {
  return function(input) {
    return (!!input) ? input.charAt(0).toUpperCase() + input.substr(1).toLowerCase() : '';
  };
});

app.filter('prettyShareMode', function() {
  return function(input) {
    var newArry = [];
    var arry = input.split(',');
    arry.forEach(function(action){
      if (action.includes('w')) {
        newArry.push('Write');
      }
      if (action.includes('r')) {
        newArry.push('Read');
      }
      if (action.includes('x')) {
        newArry.push('Invite');
      }
    });
    return newArry.join(', ');
  };
});