BookStack Code Mirror - bookstack/blob - resources/assets/js/controllers.js

   1 "use strict";
   2
   3 import moment from 'moment';
   4 import 'moment/locale/en-gb';
   5 import editorOptions from "./pages/page-form";
   6
   7 moment.locale('en-gb');
   8
   9 export default function (ngApp, events) {
  10
  11     ngApp.controller('ImageManagerController', ['$scope', '$attrs', '$http', '$timeout', 'imageManagerService',
  12         function ($scope, $attrs, $http, $timeout, imageManagerService) {
  13
  14             $scope.images = [];
  15             $scope.imageType = $attrs.imageType;
  16             $scope.selectedImage = false;
  17             $scope.dependantPages = false;
  18             $scope.showing = false;
  19             $scope.hasMore = false;
  20             $scope.imageUpdateSuccess = false;
  21             $scope.imageDeleteSuccess = false;
  22             $scope.uploadedTo = $attrs.uploadedTo;
  23             $scope.view = 'all';
  24
  25             $scope.searching = false;
  26             $scope.searchTerm = '';
  27
  28             let page = 0;
  29             let previousClickTime = 0;
  30             let previousClickImage = 0;
  31             let dataLoaded = false;
  32             let callback = false;
  33
  34             let preSearchImages = [];
  35             let preSearchHasMore = false;
  36
  37             /**
  38              * Used by dropzone to get the endpoint to upload to.
  39              * @returns {string}
  40              */
  41             $scope.getUploadUrl = function () {
  42                 return window.baseUrl('/images/' + $scope.imageType + '/upload');
  43             };
  44
  45             /**
  46              * Cancel the current search operation.
  47              */
  48             function cancelSearch() {
  49                 $scope.searching = false;
  50                 $scope.searchTerm = '';
  51                 $scope.images = preSearchImages;
  52                 $scope.hasMore = preSearchHasMore;
  53             }
  54             $scope.cancelSearch = cancelSearch;
  55
  56
  57             /**
  58              * Runs on image upload, Adds an image to local list of images
  59              * and shows a success message to the user.
  60              * @param file
  61              * @param data
  62              */
  63             $scope.uploadSuccess = function (file, data) {
  64                 $scope.$apply(() => {
  65                     $scope.images.unshift(data);
  66                 });
  67                 events.emit('success', trans('components.image_upload_success'));
  68             };
  69
  70             /**
  71              * Runs the callback and hides the image manager.
  72              * @param returnData
  73              */
  74             function callbackAndHide(returnData) {
  75                 if (callback) callback(returnData);
  76                 $scope.hide();
  77             }
  78
  79             /**
  80              * Image select action. Checks if a double-click was fired.
  81              * @param image
  82              */
  83             $scope.imageSelect = function (image) {
  84                 let dblClickTime = 300;
  85                 let currentTime = Date.now();
  86                 let timeDiff = currentTime - previousClickTime;
  87
  88                 if (timeDiff < dblClickTime && image.id === previousClickImage) {
  89                     // If double click
  90                     callbackAndHide(image);
  91                 } else {
  92                     // If single
  93                     $scope.selectedImage = image;
  94                     $scope.dependantPages = false;
  95                 }
  96                 previousClickTime = currentTime;
  97                 previousClickImage = image.id;
  98             };
  99
 100             /**
 101              * Action that runs when the 'Select image' button is clicked.
 102              * Runs the callback and hides the image manager.
 103              */
 104             $scope.selectButtonClick = function () {
 105                 callbackAndHide($scope.selectedImage);
 106             };
 107
 108             /**
 109              * Show the image manager.
 110              * Takes a callback to execute later on.
 111              * @param doneCallback
 112              */
 113             function show(doneCallback) {
 114                 callback = doneCallback;
 115                 $scope.showing = true;
 116                 $('#image-manager').find('.overlay').css('display', 'flex').hide().fadeIn(240);
 117                 // Get initial images if they have not yet been loaded in.
 118                 if (!dataLoaded) {
 119                     fetchData();
 120                     dataLoaded = true;
 121                 }
 122             }
 123
 124             // Connects up the image manger so it can be used externally
 125             // such as from TinyMCE.
 126             imageManagerService.show = show;
 127             imageManagerService.showExternal = function (doneCallback) {
 128                 $scope.$apply(() => {
 129                     show(doneCallback);
 130                 });
 131             };
 132             window.ImageManager = imageManagerService;
 133
 134             /**
 135              * Hide the image manager
 136              */
 137             $scope.hide = function () {
 138                 $scope.showing = false;
 139                 $('#image-manager').find('.overlay').fadeOut(240);
 140             };
 141
 142             let baseUrl = window.baseUrl('/images/' + $scope.imageType + '/all/');
 143
 144             /**
 145              * Fetch the list image data from the server.
 146              */
 147             function fetchData() {
 148                 let url = baseUrl + page + '?';
 149                 let components = {};
 150                 if ($scope.uploadedTo) components['page_id'] = $scope.uploadedTo;
 151                 if ($scope.searching) components['term'] = $scope.searchTerm;
 152
 153
 154                 url += Object.keys(components).map((key) => {
 155                     return key + '=' + encodeURIComponent(components[key]);
 156                 }).join('&');
 157
 158                 $http.get(url).then((response) => {
 159                     $scope.images = $scope.images.concat(response.data.images);
 160                     $scope.hasMore = response.data.hasMore;
 161                     page++;
 162                 });
 163             }
 164             $scope.fetchData = fetchData;
 165
 166             /**
 167              * Start a search operation
 168              */
 169             $scope.searchImages = function() {
 170
 171                 if ($scope.searchTerm === '') {
 172                     cancelSearch();
 173                     return;
 174                 }
 175
 176                 if (!$scope.searching) {
 177                     preSearchImages = $scope.images;
 178                     preSearchHasMore = $scope.hasMore;
 179                 }
 180
 181                 $scope.searching = true;
 182                 $scope.images = [];
 183                 $scope.hasMore = false;
 184                 page = 0;
 185                 baseUrl = window.baseUrl('/images/' + $scope.imageType + '/search/');
 186                 fetchData();
 187             };
 188
 189             /**
 190              * Set the current image listing view.
 191              * @param viewName
 192              */
 193             $scope.setView = function(viewName) {
 194                 cancelSearch();
 195                 $scope.images = [];
 196                 $scope.hasMore = false;
 197                 page = 0;
 198                 $scope.view = viewName;
 199                 baseUrl = window.baseUrl('/images/' + $scope.imageType  + '/' + viewName + '/');
 200                 fetchData();
 201             };
 202
 203             /**
 204              * Save the details of an image.
 205              * @param event
 206              */
 207             $scope.saveImageDetails = function (event) {
 208                 event.preventDefault();
 209                 let url = window.baseUrl('/images/update/' + $scope.selectedImage.id);
 210                 $http.put(url, this.selectedImage).then(response => {
 211                     events.emit('success', trans('components.image_update_success'));
 212                 }, (response) => {
 213                     if (response.status === 422) {
 214                         let errors = response.data;
 215                         let message = '';
 216                         Object.keys(errors).forEach((key) => {
 217                             message += errors[key].join('\n');
 218                         });
 219                         events.emit('error', message);
 220                     } else if (response.status === 403) {
 221                         events.emit('error', response.data.error);
 222                     }
 223                 });
 224             };
 225
 226             /**
 227              * Delete an image from system and notify of success.
 228              * Checks if it should force delete when an image
 229              * has dependant pages.
 230              * @param event
 231              */
 232             $scope.deleteImage = function (event) {
 233                 event.preventDefault();
 234                 let force = $scope.dependantPages !== false;
 235                 let url = window.baseUrl('/images/' + $scope.selectedImage.id);
 236                 if (force) url += '?force=true';
 237                 $http.delete(url).then((response) => {
 238                     $scope.images.splice($scope.images.indexOf($scope.selectedImage), 1);
 239                     $scope.selectedImage = false;
 240                     events.emit('success', trans('components.image_delete_success'));
 241                 }, (response) => {
 242                     // Pages failure
 243                     if (response.status === 400) {
 244                         $scope.dependantPages = response.data;
 245                     } else if (response.status === 403) {
 246                         events.emit('error', response.data.error);
 247                     }
 248                 });
 249             };
 250
 251             /**
 252              * Simple date creator used to properly format dates.
 253              * @param stringDate
 254              * @returns {Date}
 255              */
 256             $scope.getDate = function (stringDate) {
 257                 return new Date(stringDate);
 258             };
 259
 260         }]);
 261
 262
 263     ngApp.controller('BookShowController', ['$scope', '$http', '$attrs', '$sce', function ($scope, $http, $attrs, $sce) {
 264         $scope.searching = false;
 265         $scope.searchTerm = '';
 266         $scope.searchResults = '';
 267
 268         $scope.searchBook = function (e) {
 269             e.preventDefault();
 270             let term = $scope.searchTerm;
 271             if (term.length == 0) return;
 272             $scope.searching = true;
 273             $scope.searchResults = '';
 274             let searchUrl = window.baseUrl('/search/book/' + $attrs.bookId);
 275             searchUrl += '?term=' + encodeURIComponent(term);
 276             $http.get(searchUrl).then((response) => {
 277                 $scope.searchResults = $sce.trustAsHtml(response.data);
 278             });
 279         };
 280
 281         $scope.checkSearchForm = function () {
 282             if ($scope.searchTerm.length < 1) {
 283                 $scope.searching = false;
 284             }
 285         };
 286
 287         $scope.clearSearch = function () {
 288             $scope.searching = false;
 289             $scope.searchTerm = '';
 290         };
 291
 292     }]);
 293
 294
 295     ngApp.controller('PageEditController', ['$scope', '$http', '$attrs', '$interval', '$timeout', '$sce',
 296         function ($scope, $http, $attrs, $interval, $timeout, $sce) {
 297
 298         $scope.editorOptions = editorOptions();
 299         $scope.editContent = '';
 300         $scope.draftText = '';
 301         let pageId = Number($attrs.pageId);
 302         let isEdit = pageId !== 0;
 303         let autosaveFrequency = 30; // AutoSave interval in seconds.
 304         let isMarkdown = $attrs.editorType === 'markdown';
 305         $scope.draftsEnabled = $attrs.draftsEnabled === 'true';
 306         $scope.isUpdateDraft = Number($attrs.pageUpdateDraft) === 1;
 307         $scope.isNewPageDraft = Number($attrs.pageNewDraft) === 1;
 308
 309         // Set initial header draft text
 310         if ($scope.isUpdateDraft || $scope.isNewPageDraft) {
 311             $scope.draftText = trans('entities.pages_editing_draft');
 312         } else {
 313             $scope.draftText = trans('entities.pages_editing_page');
 314         }
 315
 316         let autoSave = false;
 317
 318         let currentContent = {
 319             title: false,
 320             html: false
 321         };
 322
 323         if (isEdit && $scope.draftsEnabled) {
 324             setTimeout(() => {
 325                 startAutoSave();
 326             }, 1000);
 327         }
 328
 329         // Actions specifically for the markdown editor
 330         if (isMarkdown) {
 331             $scope.displayContent = '';
 332             // Editor change event
 333             $scope.editorChange = function (content) {
 334                 $scope.displayContent = $sce.trustAsHtml(content);
 335             }
 336         }
 337
 338         if (!isMarkdown) {
 339             $scope.editorChange = function() {};
 340         }
 341
 342         let lastSave = 0;
 343
 344         /**
 345          * Start the AutoSave loop, Checks for content change
 346          * before performing the costly AJAX request.
 347          */
 348         function startAutoSave() {
 349             currentContent.title = $('#name').val();
 350             currentContent.html = $scope.editContent;
 351
 352             autoSave = $interval(() => {
 353                 // Return if manually saved recently to prevent bombarding the server
 354                 if (Date.now() - lastSave < (1000*autosaveFrequency)/2) return;
 355                 let newTitle = $('#name').val();
 356                 let newHtml = $scope.editContent;
 357
 358                 if (newTitle !== currentContent.title || newHtml !== currentContent.html) {
 359                     currentContent.html = newHtml;
 360                     currentContent.title = newTitle;
 361                     saveDraft();
 362                 }
 363
 364             }, 1000 * autosaveFrequency);
 365         }
 366
 367         let draftErroring = false;
 368         /**
 369          * Save a draft update into the system via an AJAX request.
 370          */
 371         function saveDraft() {
 372             if (!$scope.draftsEnabled) return;
 373             let data = {
 374                 name: $('#name').val(),
 375                 html: isMarkdown ? $sce.getTrustedHtml($scope.displayContent) : $scope.editContent
 376             };
 377
 378             if (isMarkdown) data.markdown = $scope.editContent;
 379
 380             let url = window.baseUrl('/ajax/page/' + pageId + '/save-draft');
 381             $http.put(url, data).then(responseData => {
 382                 draftErroring = false;
 383                 let updateTime = moment.utc(moment.unix(responseData.data.timestamp)).toDate();
 384                 $scope.draftText = responseData.data.message + moment(updateTime).format('HH:mm');
 385                 if (!$scope.isNewPageDraft) $scope.isUpdateDraft = true;
 386                 showDraftSaveNotification();
 387                 lastSave = Date.now();
 388             }, errorRes => {
 389                 if (draftErroring) return;
 390                 events.emit('error', trans('errors.page_draft_autosave_fail'));
 391                 draftErroring = true;
 392             });
 393         }
 394
 395         function showDraftSaveNotification() {
 396             $scope.draftUpdated = true;
 397             $timeout(() => {
 398                 $scope.draftUpdated = false;
 399             }, 2000)
 400         }
 401
 402         $scope.forceDraftSave = function() {
 403             saveDraft();
 404         };
 405
 406         // Listen to shortcuts coming via events
 407         $scope.$on('editor-keydown', (event, data) => {
 408             // Save shortcut (ctrl+s)
 409             if (data.keyCode == 83 && (navigator.platform.match("Mac") ? data.metaKey : data.ctrlKey)) {
 410                 data.preventDefault();
 411                 saveDraft();
 412             }
 413         });
 414
 415         /**
 416          * Discard the current draft and grab the current page
 417          * content from the system via an AJAX request.
 418          */
 419         $scope.discardDraft = function () {
 420             let url = window.baseUrl('/ajax/page/' + pageId);
 421             $http.get(url).then((responseData) => {
 422                 if (autoSave) $interval.cancel(autoSave);
 423                 $scope.draftText = trans('entities.pages_editing_page');
 424                 $scope.isUpdateDraft = false;
 425                 $scope.$broadcast('html-update', responseData.data.html);
 426                 $scope.$broadcast('markdown-update', responseData.data.markdown || responseData.data.html);
 427                 $('#name').val(responseData.data.name);
 428                 $timeout(() => {
 429                     startAutoSave();
 430                 }, 1000);
 431                 events.emit('success', trans('entities.pages_draft_discarded'));
 432             });
 433         };
 434
 435     }]);
 436
 437     ngApp.controller('PageTagController', ['$scope', '$http', '$attrs',
 438         function ($scope, $http, $attrs) {
 439
 440             const pageId = Number($attrs.pageId);
 441             $scope.tags = [];
 442
 443             $scope.sortOptions = {
 444                 handle: '.handle',
 445                 items: '> tr',
 446                 containment: "parent",
 447                 axis: "y"
 448             };
 449
 450             /**
 451              * Push an empty tag to the end of the scope tags.
 452              */
 453             function addEmptyTag() {
 454                 $scope.tags.push({
 455                     name: '',
 456                     value: ''
 457                 });
 458             }
 459             $scope.addEmptyTag = addEmptyTag;
 460
 461             /**
 462              * Get all tags for the current book and add into scope.
 463              */
 464             function getTags() {
 465                 let url = window.baseUrl(`/ajax/tags/get/page/${pageId}`);
 466                 $http.get(url).then((responseData) => {
 467                     $scope.tags = responseData.data;
 468                     addEmptyTag();
 469                 });
 470             }
 471             getTags();
 472
 473             /**
 474              * Set the order property on all tags.
 475              */
 476             function setTagOrder() {
 477                 for (let i = 0; i < $scope.tags.length; i++) {
 478                     $scope.tags[i].order = i;
 479                 }
 480             }
 481
 482             /**
 483              * When an tag changes check if another empty editable
 484              * field needs to be added onto the end.
 485              * @param tag
 486              */
 487             $scope.tagChange = function(tag) {
 488                 let cPos = $scope.tags.indexOf(tag);
 489                 if (cPos !== $scope.tags.length-1) return;
 490
 491                 if (tag.name !== '' || tag.value !== '') {
 492                     addEmptyTag();
 493                 }
 494             };
 495
 496             /**
 497              * When an tag field loses focus check the tag to see if its
 498              * empty and therefore could be removed from the list.
 499              * @param tag
 500              */
 501             $scope.tagBlur = function(tag) {
 502                 let isLast = $scope.tags.length - 1 === $scope.tags.indexOf(tag);
 503                 if (tag.name === '' && tag.value === '' && !isLast) {
 504                     let cPos = $scope.tags.indexOf(tag);
 505                     $scope.tags.splice(cPos, 1);
 506                 }
 507             };
 508
 509             /**
 510              * Remove a tag from the current list.
 511              * @param tag
 512              */
 513             $scope.removeTag = function(tag) {
 514                 let cIndex = $scope.tags.indexOf(tag);
 515                 $scope.tags.splice(cIndex, 1);
 516             };
 517
 518         }]);
 519
 520
 521     ngApp.controller('PageAttachmentController', ['$scope', '$http', '$attrs',
 522         function ($scope, $http, $attrs) {
 523
 524             const pageId = $scope.uploadedTo = $attrs.pageId;
 525             let currentOrder = '';
 526             $scope.files = [];
 527             $scope.editFile = false;
 528             $scope.file = getCleanFile();
 529             $scope.errors = {
 530                 link: {},
 531                 edit: {}
 532             };
 533
 534             function getCleanFile() {
 535                 return {
 536                     page_id: pageId
 537                 };
 538             }
 539
 540             // Angular-UI-Sort options
 541             $scope.sortOptions = {
 542                 handle: '.handle',
 543                 items: '> tr',
 544                 containment: "parent",
 545                 axis: "y",
 546                 stop: sortUpdate,
 547             };
 548
 549             /**
 550              * Event listener for sort changes.
 551              * Updates the file ordering on the server.
 552              * @param event
 553              * @param ui
 554              */
 555             function sortUpdate(event, ui) {
 556                 let newOrder = $scope.files.map(file => {return file.id}).join(':');
 557                 if (newOrder === currentOrder) return;
 558
 559                 currentOrder = newOrder;
 560                 $http.put(window.baseUrl(`/attachments/sort/page/${pageId}`), {files: $scope.files}).then(resp => {
 561                     events.emit('success', resp.data.message);
 562                 }, checkError('sort'));
 563             }
 564
 565             /**
 566              * Used by dropzone to get the endpoint to upload to.
 567              * @returns {string}
 568              */
 569             $scope.getUploadUrl = function (file) {
 570                 let suffix = (typeof file !== 'undefined') ? `/${file.id}` : '';
 571                 return window.baseUrl(`/attachments/upload${suffix}`);
 572             };
 573
 574             /**
 575              * Get files for the current page from the server.
 576              */
 577             function getFiles() {
 578                 let url = window.baseUrl(`/attachments/get/page/${pageId}`);
 579                 $http.get(url).then(resp => {
 580                     $scope.files = resp.data;
 581                     currentOrder = resp.data.map(file => {return file.id}).join(':');
 582                 }, checkError('get'));
 583             }
 584             getFiles();
 585
 586             /**
 587              * Runs on file upload, Adds an file to local file list
 588              * and shows a success message to the user.
 589              * @param file
 590              * @param data
 591              */
 592             $scope.uploadSuccess = function (file, data) {
 593                 $scope.$apply(() => {
 594                     $scope.files.push(data);
 595                 });
 596                 events.emit('success', trans('entities.attachments_file_uploaded'));
 597             };
 598
 599             /**
 600              * Upload and overwrite an existing file.
 601              * @param file
 602              * @param data
 603              */
 604             $scope.uploadSuccessUpdate = function (file, data) {
 605                 $scope.$apply(() => {
 606                     let search = filesIndexOf(data);
 607                     if (search !== -1) $scope.files[search] = data;
 608
 609                     if ($scope.editFile) {
 610                         $scope.editFile = angular.copy(data);
 611                         data.link = '';
 612                     }
 613                 });
 614                 events.emit('success', trans('entities.attachments_file_updated'));
 615             };
 616
 617             /**
 618              * Delete a file from the server and, on success, the local listing.
 619              * @param file
 620              */
 621             $scope.deleteFile = function(file) {
 622                 if (!file.deleting) {
 623                     file.deleting = true;
 624                     return;
 625                 }
 626                   $http.delete(window.baseUrl(`/attachments/${file.id}`)).then(resp => {
 627                       events.emit('success', resp.data.message);
 628                       $scope.files.splice($scope.files.indexOf(file), 1);
 629                   }, checkError('delete'));
 630             };
 631
 632             /**
 633              * Attach a link to a page.
 634              * @param file
 635              */
 636             $scope.attachLinkSubmit = function(file) {
 637                 file.uploaded_to = pageId;
 638                 $http.post(window.baseUrl('/attachments/link'), file).then(resp => {
 639                     $scope.files.push(resp.data);
 640                     events.emit('success', trans('entities.attachments_link_attached'));
 641                     $scope.file = getCleanFile();
 642                 }, checkError('link'));
 643             };
 644
 645             /**
 646              * Start the edit mode for a file.
 647              * @param file
 648              */
 649             $scope.startEdit = function(file) {
 650                 $scope.editFile = angular.copy(file);
 651                 $scope.editFile.link = (file.external) ? file.path : '';
 652             };
 653
 654             /**
 655              * Cancel edit mode
 656              */
 657             $scope.cancelEdit = function() {
 658                 $scope.editFile = false;
 659             };
 660
 661             /**
 662              * Update the name and link of a file.
 663              * @param file
 664              */
 665             $scope.updateFile = function(file) {
 666                 $http.put(window.baseUrl(`/attachments/${file.id}`), file).then(resp => {
 667                     let search = filesIndexOf(resp.data);
 668                     if (search !== -1) $scope.files[search] = resp.data;
 669
 670                     if ($scope.editFile && !file.external) {
 671                         $scope.editFile.link = '';
 672                     }
 673                     $scope.editFile = false;
 674                     events.emit('success', trans('entities.attachments_updated_success'));
 675                 }, checkError('edit'));
 676             };
 677
 678             /**
 679              * Get the url of a file.
 680              */
 681             $scope.getFileUrl = function(file) {
 682                 return window.baseUrl('/attachments/' + file.id);
 683             };
 684
 685             /**
 686              * Search the local files via another file object.
 687              * Used to search via object copies.
 688              * @param file
 689              * @returns int
 690              */
 691             function filesIndexOf(file) {
 692                 for (let i = 0; i < $scope.files.length; i++) {
 693                     if ($scope.files[i].id == file.id) return i;
 694                 }
 695                 return -1;
 696             }
 697
 698             /**
 699              * Check for an error response in a ajax request.
 700              * @param errorGroupName
 701              */
 702             function checkError(errorGroupName) {
 703                 $scope.errors[errorGroupName] = {};
 704                 return function(response) {
 705                     if (typeof response.data !== 'undefined' && typeof response.data.error !== 'undefined') {
 706                         events.emit('error', response.data.error);
 707                     }
 708                     if (typeof response.data !== 'undefined' && typeof response.data.validation !== 'undefined') {
 709                         $scope.errors[errorGroupName] = response.data.validation;
 710                         console.log($scope.errors[errorGroupName])
 711                     }
 712                 }
 713             }
 714
 715         }]);
 716
 717 };