pageflow 0.0.1

data/app/assets/javascripts/pageflow/editor/models/edit_lock.js

@@ -0,0 +1,14 @@
+pageflow.EditLock = Backbone.Model.extend({
+  paramRoot: 'edit_lock',
+
+  url: function() {
+    return pageflow.entry.url() + '/edit_lock?timestamp=' + new Date().getTime();
+  },
+
+  toJSON: function() {
+    return {
+      id: this.id,
+      force: this.get('force')
+    };
+  }
+});

data/app/assets/javascripts/pageflow/editor/models/edit_lock_container.js

@@ -0,0 +1,73 @@
+pageflow.EditLockContainer = Backbone.Model.extend({
+  initialize: function() {
+    this.storageKey = 'pageflow.edit_lock.' + pageflow.entry.id;
+  },
+
+  aquire: function(options) {
+    options = options || {};
+    var container = this;
+
+    var lock = new pageflow.EditLock({
+      id: options.force ? null : sessionStorage[this.storageKey],
+      force: options.force
+    });
+
+    lock.save(null, {
+      polling: !!options.polling,
+      success: function(lock) {
+        sessionStorage[container.storageKey] = lock.id;
+
+        container.lock = lock;
+        container.trigger('aquired');
+
+        container.startPolling();
+      }
+    });
+  },
+
+  startPolling: function() {
+    if (!this.pollingInteval) {
+      this.pollingInteval = setInterval(_.bind(function() {
+        this.aquire({polling: true});
+      }, this), 2000);
+    }
+  },
+
+  stopPolling: function() {
+    if (this.pollingInteval) {
+      clearInterval(this.pollingInteval);
+      this.pollingInteval = null;
+    }
+  },
+
+  watchForErrors: function() {
+    var container = this;
+
+    $(document).ajaxSend(function(event, xhr) {
+      if (container.lock) {
+        xhr.setRequestHeader("X-Edit-Lock", container.lock.id);
+      }
+    });
+
+    $(document).ajaxError(function(event, xhr, settings) {
+      if (xhr.status === 409) {
+        container.lock = null;
+        container.trigger('locked',
+                          xhr.responseJSON || {},
+                          {
+                            context: (settings.url.match(/\/edit_lock/) && !settings.polling) ? 'aquire' : 'other'
+                          });
+
+        container.stopPolling();
+      }
+    });
+  },
+
+  release: function() {
+    if (this.lock) {
+      var promise = this.lock.destroy();
+      this.lock = null;
+      return promise;
+    }
+  }
+});

data/app/assets/javascripts/pageflow/editor/models/entry.js

@@ -0,0 +1,134 @@
+pageflow.Entry = Backbone.Model.extend({
+  paramRoot: 'entry',
+  urlRoot: '/entries',
+  modelName: 'entry',
+
+  mixins: [pageflow.filesCountWatcher, pageflow.polling, pageflow.failureTracking],
+
+  initialize: function() {
+    this.chapters = pageflow.chapters;
+    this.chapters.parentModel = this;
+    this.pages = pageflow.pages;
+
+    this.imageFiles = pageflow.imageFiles;
+    this.videoFiles = pageflow.videoFiles;
+    this.audioFiles = pageflow.audioFiles;
+
+    this.listenTo(this.chapters, 'sort', function() {
+      this.pages.sort();
+    });
+
+    this.listenTo(this, 'change:title change:summary change:credits change:manual_start', function() {
+      this.save();
+    });
+
+    this.watchFileCollection('image_files', this.imageFiles);
+    this.watchFileCollection('video_files', this.videoFiles);
+    this.watchFileCollection('audio_files', this.audioFiles);
+  },
+
+  addChapter: function() {
+    this.chapters.create({
+      entry_id: this.get('id'),
+      position: this.chapters.length
+    });
+  },
+
+  addFile: function(file) {
+    var record;
+
+    if (file.type.match(/^image/)) {
+      record = new pageflow.ImageFile({
+        state: 'uploading',
+        file_name: file.name
+      });
+      pageflow.imageFiles.add(record);
+    }
+    else if (file.type.match(/^video/)) {
+      record = new pageflow.VideoFile({
+        state: 'uploading',
+        file_name: file.name
+      });
+      pageflow.videoFiles.add(record);
+    }
+    else if (file.type.match(/^audio/)) {
+      record = new pageflow.AudioFile({
+        state: 'uploading',
+        file_name: file.name
+      });
+      pageflow.audioFiles.add(record);
+    }
+
+    return record;
+  },
+
+  addFileUsage: function(file) {
+    this.createFileUsage(file, { success: function(usage) {
+      file.set('usage_id', usage.get('id'));
+      this.addFileToCollection(file);
+    }.bind(this)});
+  },
+
+  createFileUsage: function(file, options) {
+    var file_usages = new pageflow.FileUsagesCollection();
+
+    return file_usages.create({
+      file_id: file.get('id'),
+      file_type: file.get('typeName')
+    }, options);
+
+  },
+
+  addFileToCollection: function (file) {
+    this.getFileCollection(file.get('typeName')).add(file);
+  },
+
+  getFileCollection: function(filetype) {
+    return this[lowerCaseFirst(filetype) + 's'];
+
+    function lowerCaseFirst(string) {
+      return string.charAt(0).toLowerCase() + string.slice(1);
+    }
+  },
+
+  pollForPendingFiles: function() {
+    this.listenTo(this, 'change:pending_files_count', function(model, value) {
+      this.togglePolling(value > 0);
+    });
+
+    this.togglePolling(this.get('pending_files_count') > 0);
+  },
+
+  publish: function(attrs) {
+    var model = this;
+
+    return Backbone.sync('create', this, {
+      url: this.url() + '/revisions',
+      attrs: attrs,
+
+      success: function(response) {
+        model.parse(response);
+      }
+    });
+  },
+
+  parse: function(response, options) {
+    if (response) {
+      this.set(_.pick(response, 'published', 'published_until'));
+
+      this.imageFiles.set(response.image_files, {add: false, remove: false});
+      this.videoFiles.set(response.video_files, {add: false, remove: false});
+      this.audioFiles.set(response.audio_files, {add: false, remove: false});
+
+      delete response.image_files;
+      delete response.video_files;
+      delete response.audio_files;
+    }
+
+    return response;
+  },
+
+  toJSON: function() {
+    return _.pick(this.attributes, 'title', 'summary', 'credits', 'manual_start');
+  }
+});

data/app/assets/javascripts/pageflow/editor/models/file_stage.js

@@ -0,0 +1,54 @@
+pageflow.FileStage = Backbone.Model.extend({
+  initialize: function(attributes,  options) {
+    this.file = options.file;
+
+    this.activeStates = options.activeStates;
+    this.finishedStates = options.finishedStates;
+    this.failedStates = options.failedStates;
+
+    this.update();
+    this.listenTo(this.file, 'change:state', this.update);
+    this.listenTo(this.file, 'change:encoding_progress', this.update);
+    this.listenTo(this.file, 'change:uploading_progress', this.update);
+  },
+
+  update: function() {
+    this.updateState();
+    this.updateProgress();
+    this.updateErrorMessage();
+  },
+
+  updateState: function() {
+    var state = this.file.get('state');
+
+    this.set('active', this.activeStates.indexOf(state) >= 0);
+    this.set('finished', this.finishedStates.indexOf(state) >= 0);
+    this.set('failed', this.failedStates.indexOf(state) >= 0);
+
+    if (this.get('active')) {
+      this.set('state', 'active');
+    }
+    else if (this.get('finished')) {
+      this.set('state', 'finished');
+    }
+    else if (this.get('failed')) {
+      this.set('state', 'failed');
+    }
+    else {
+      this.set('state', 'pending');
+    }
+  },
+
+  updateProgress: function() {
+    this.set('progress', this.file.get(this.get('name') + '_progress'));
+  },
+
+  updateErrorMessage: function() {
+    var errorMessageAttribute = this.get('name').replace('_failed', '') + '_error_message';
+    this.set('error_message', this.file.get(errorMessageAttribute));
+  },
+
+  localizedDescription: function() {
+    return I18n.t('editor.files.stages.' + this.get('name') + '.' + this.get('state'));
+  }
+});

data/app/assets/javascripts/pageflow/editor/models/file_usage.js

@@ -0,0 +1,8 @@
+pageflow.FileUsage = Backbone.Model.extend({
+  modelName: 'file_usage',
+  paramRoot: 'file_usage',
+
+  urlRoot: function() {
+    return this.isNew() ? this.collection.url() : '/editor/file_usages/';
+  }
+});

data/app/assets/javascripts/pageflow/editor/models/image_file.js

@@ -0,0 +1,39 @@
+pageflow.ImageFile = Backbone.Model.extend({
+  modelName: 'image_file',
+  paramRoot: 'image_file',
+
+  mixins: [pageflow.file, pageflow.stageProvider, pageflow.retryable],
+
+  stageMapping: {
+    uploading: {
+      activeStates: ['uploading'],
+      finishedStates: ['processing', 'processed', 'processing_failed'],
+      failedStates: ['upload_failed']
+    },
+    processing: {
+      activeStates: ['processing'],
+      finishedStates: ['processed'],
+      failedStates: ['processing_failed']
+    }
+  },
+
+  urlRoot: function() {
+    return this.isNew() ? this.collection.url() : '/editor/image_files';
+  },
+
+  isReady: function() {
+    return this.get('state') === 'processed';
+  },
+
+  isPending: function() {
+    return this.get('state') === 'processing';
+  },
+
+  isRetryable: function() {
+    return this.get('state') === 'processing_failed';
+  },
+
+  isPositionable: function() {
+    return this.isReady();
+  }
+});

data/app/assets/javascripts/pageflow/editor/models/mixins/delayed_destroying.js

@@ -0,0 +1,26 @@
+pageflow.delayedDestroying = {
+  initialize: function() {
+    this._destroying = false;
+  },
+
+  destroyWithDelay: function() {
+    var model = this;
+
+    this.trigger('destroying', this);
+    this._destroying = true;
+
+    return Backbone.Model.prototype.destroy.call(this, {
+      wait: true,
+      success: function() {
+        model._destroying = false;
+      },
+      error: function() {
+        model._destroying = false;
+      }
+    });
+  },
+
+  isDestroying: function() {
+    return this._destroying;
+  }
+};

data/app/assets/javascripts/pageflow/editor/models/mixins/encoded_file.js

@@ -0,0 +1,34 @@
+pageflow.encodedFile = {
+  stageMapping: {
+    uploading: {
+      activeStates: ['uploading'],
+      finishedStates: ['not_uploaded_to_s3', 'upload_to_s3', 'uploading_to_s3', 'upload_to_s3_failed', 'waiting_for_encoding', 'encoding', 'encoded', 'encoding_failed'],
+      failedStates: ['upload_failed']
+    },
+    uploading_to_s3: {
+      activeStates: ['uploading_to_s3'],
+      finishedStates: ['waiting_for_encoding', 'encoding', 'encoded', 'encoding_failed'],
+      failedStates: ['upload_to_s3_failed']},
+    encoding: {
+      activeStates: ['waiting_for_encoding', 'encoding'],
+      finishedStates: ['encoded'],
+      failedStates: ['encoding_failed']
+    }
+  },
+
+  isReady: function() {
+    return this.get('state') === 'encoded';
+  },
+
+  isFailed: function() {
+    return this.get('state').match(/_failed$/);
+  },
+
+  isPending: function() {
+    return !this.isUploading() && !this.isReady() && !this.isFailed();
+  },
+
+  isRetryable: function() {
+    return ['upload_to_s3_failed', 'encoding_failed'].indexOf(this.get('state')) >= 0;
+  },
+};

data/app/assets/javascripts/pageflow/editor/models/mixins/failure_tracking.js

@@ -0,0 +1,47 @@
+pageflow.failureTracking = {
+  initialize: function() {
+    this._saveFailed = false;
+
+    this.listenTo(this, 'sync', function() {
+      this._saveFailed = false;
+      this._failureMessage = null;
+      this.trigger('change:failed');
+    });
+
+    this.listenTo(this, 'error', function(model, xhr) {
+      this._saveFailed = true;
+      this._failureMessage = this.translateStatus(xhr);
+      this.trigger('change:failed');
+    });
+  },
+
+  isFailed: function() {
+    return this._saveFailed;
+  },
+
+  getFailureMessage: function() {
+    return this._failureMessage;
+  },
+
+  translateStatus: function(xhr) {
+    if (xhr.status === 401) {
+      return 'Sie müssen angemeldet sein, um diese Aktion auszuführen.';
+    }
+    else if (xhr.status === 403) {
+      return 'Sie sind nicht berechtigt diese Aktion auszuführen.';
+    }
+    else if (xhr.status === 404) {
+      return 'Der Datensatz konnte auf dem Server nicht gefunden werden.';
+    }
+    else if (xhr.status === 409) {
+      return 'Die Reportage wurde außerhalb dieses Editors bearbeitet.';
+    }
+    else if (xhr.status >= 500 && xhr.status < 600) {
+      return 'Der Server hat einen internen Fehler gemeldet.';
+    }
+    else if (xhr.statusText === 'timeout') {
+      return 'Der Server ist nicht erreichbar.';
+    }
+    return '';
+  }
+};

data/app/assets/javascripts/pageflow/editor/models/mixins/file.js

@@ -0,0 +1,31 @@
+pageflow.file = {
+  cancelUpload: function() {
+    if (this.get('state') === 'uploading') {
+      this.trigger('uploadCancelled');
+      this.destroy();
+    }
+  },
+
+  uploadFailed: function() {
+    this.set('state', 'upload_failed');
+    this.unset('uploading_progress');
+
+    this.trigger('uploadFailed');
+  },
+
+  isUploading: function() {
+    return this.get('state') === 'uploading';
+  },
+
+  isUploaded: function() {
+    return this.get('state') !== 'uploading' && this.get('state') !== 'upload_failed';
+  },
+
+  destroyUsage: function() {
+    var usage = new pageflow.FileUsage({id: this.get('usage_id')});
+
+    usage.destroy();
+
+    this.trigger('destroy', this, this.collection, {});
+  }
+};