scripts/elfinder-2.0-rc1/js/proxy/elFinderSupportVer1.js

   1 "use strict";
   2 /**
   3  * elFinder transport to support old protocol.
   4  *
   5  * @example
   6  * $('selector').elfinder({
   7  *   ....
   8  *   transport : new elFinderSupportVer1()
   9  * })
  10  *
  11  * @author Dmitry (dio) Levashov
  12  **/
  13 window.elFinderSupportVer1 = function(upload) {
  14         var self = this;
  15
  16         this.upload = upload || 'auto';
  17
  18         this.init = function(fm) {
  19                 this.fm = fm;
  20                 this.fm.parseUploadData = function(text) {
  21                         var data;
  22
  23                         if (!$.trim(text)) {
  24                                 return {error : ['errResponse', 'errDataEmpty']};
  25                         }
  26
  27                         try {
  28                                 data = $.parseJSON(text);
  29                         } catch (e) {
  30                                 return {error : ['errResponse', 'errDataNotJSON']}
  31                         }
  32
  33                         return self.normalize('upload', data);
  34                 }
  35         }
  36
  37
  38         this.send = function(opts) {
  39                 var self = this,
  40                         fm = this.fm,
  41                         dfrd = $.Deferred(),
  42                         cmd = opts.data.cmd,
  43                         args = [],
  44                         _opts = {},
  45                         data,
  46                         xhr;
  47
  48                 dfrd.abort = function() {
  49                         !xhr.isRejected() && !xhr.isResolved() && xhr.abort();
  50                 }
  51
  52                 switch (cmd) {
  53                         case 'open':
  54                                 opts.data.tree = 1;
  55                                 break;
  56                         case 'parents':
  57                         case 'tree':
  58                                 return dfrd.resolve({tree : []});
  59                                 break;
  60                         case 'get':
  61                                 opts.data.cmd = 'read';
  62                                 opts.data.current = fm.file(opts.data.target).phash;
  63                                 break;
  64                         case 'put':
  65                                 opts.data.cmd = 'edit';
  66                                 opts.data.current = fm.file(opts.data.target).phash;
  67                                 break;
  68                         case 'archive':
  69                         case 'rm':
  70                                 opts.data.current = fm.file(opts.data.targets[0]).phash;
  71                                 break;
  72                         case 'extract':
  73                         case 'rename':
  74                         case 'resize':
  75                                 opts.data.current = fm.file(opts.data.target).phash;
  76                                 break;
  77                         case 'duplicate':
  78                                 _opts = $.extend(true, {}, opts);
  79
  80                                 $.each(opts.data.targets, function(i, hash) {
  81                                         $.ajax($.extend(_opts, {data : {cmd : 'duplicate', target : hash, current : fm.file(hash).phash}}))
  82                                                 .error(function(error) {
  83                                                         fm.error(fm.res('error', 'connect'));
  84                                                 })
  85                                                 .done(function(data) {
  86                                                         data = self.normalize('duplicate', data);
  87                                                         if (data.error) {
  88                                                                 fm.error(data.error);
  89                                                         } else if (data.added) {
  90                                                                 fm.trigger('add', {added : data.added});
  91                                                         }
  92                                                 })
  93                                 });
  94                                 return dfrd.resolve({})
  95                                 break;
  96
  97                         case 'mkdir':
  98                         case 'mkfile':
  99                                 opts.data.current = opts.data.target;
 100                                 break;
 101                         case 'paste':
 102                                 opts.data.current = opts.data.dst
 103                                 break;
 104
 105                         case 'size':
 106                                 return dfrd.resolve({error : fm.res('error', 'cmdsupport')});
 107                                 break;
 108                         case 'search':
 109                                 return dfrd.resolve({error : fm.res('error', 'cmdsupport')});
 110                                 break;
 111
 112                 }
 113                 // cmd = opts.data.cmd
 114
 115                 xhr = $.ajax(opts)
 116                         .fail(function(error) {
 117                                 dfrd.reject(error)
 118                         })
 119                         .done(function(raw) {
 120                                 data = self.normalize(cmd, raw);
 121
 122                                 // cmd != 'open' && self.fm.log(data);
 123
 124                                 if (cmd == 'paste' && !data.error) {
 125                                         fm.sync();
 126                                         dfrd.resolve({});
 127                                 } else {
 128                                         dfrd.resolve(data);
 129                                 }
 130                         })
 131
 132                 return dfrd;
 133
 134                 return $.ajax(opts);
 135         }
 136
 137         // fix old connectors errors messages as possible
 138         // this.errors = {
 139         //      'Unknown command'                                  : 'Unknown command.',
 140         //      'Invalid backend configuration'                    : 'Invalid backend configuration.',
 141         //      'Access denied'                                    : 'Access denied.',
 142         //      'PHP JSON module not installed'                    : 'PHP JSON module not installed.',
 143         //      'File not found'                                   : 'File not found.',
 144         //      'Invalid name'                                     : 'Invalid file name.',
 145         //      'File or folder with the same name already exists' : 'File named "$1" already exists in this location.',
 146         //      'Not allowed file type'                            : 'Not allowed file type.',
 147         //      'File exceeds the maximum allowed filesize'        : 'File exceeds maximum allowed size.',
 148         //      'Unable to copy into itself'                       : 'Unable to copy "$1" into itself.',
 149         //      'Unable to create archive'                         : 'Unable to create archive.',
 150         //      'Unable to extract files from archive'             : 'Unable to extract files from "$1".'
 151         // }
 152
 153         this.normalize = function(cmd, data) {
 154                 var self = this,
 155                         files = {},
 156                         filter = function(file) { return file && file.hash && file.name && file.mime ? file : null; },
 157                         phash;
 158
 159                 if ((cmd == 'tmb' || cmd == 'get')) {
 160                         return data;
 161                 }
 162
 163                 // if (data.error) {
 164                 //      $.each(data.error, function(i, msg) {
 165                 //              if (self.errors[msg]) {
 166                 //                      data.error[i] = self.errors[msg];
 167                 //              }
 168                 //      });
 169                 // }
 170
 171                 if (cmd == 'upload' && data.error && data.cwd) {
 172                         data.warning = $.extend({}, data.error);
 173                         data.error = false;
 174                 }
 175
 176
 177                 if (data.error) {
 178                         return data;
 179                 }
 180
 181                 if (cmd == 'put') {
 182
 183                         phash = this.fm.file(data.target.hash).phash;
 184                         return {changed : [this.normalizeFile(data.target, phash)]};
 185                 }
 186
 187                 phash = data.cwd.hash;
 188
 189                 if (data.tree) {
 190                         $.each(this.normalizeTree(data.tree), function(i, file) {
 191                                 files[file.hash] = file;
 192                         });
 193                 }
 194
 195                 $.each(data.cdc||[], function(i, file) {
 196                         var hash = file.hash;
 197
 198                         if (files[hash]) {
 199                                 files[hash].date   = file.date;
 200                                 files[hash].locked = file.hash == phash ? true : file.rm === void(0) ? false : !file.rm;
 201                         } else {
 202                                 files[hash] = self.normalizeFile(file, phash, data.tmb);
 203                         }
 204                 });
 205
 206                 if (!data.tree) {
 207                         $.each(this.fm.files(), function(hash, file) {
 208                                 if (!files[hash] && file.phash != phash && file.mime == 'directory') {
 209                                         files[hash] = file;
 210                                 }
 211                         });
 212                 }
 213
 214                 if (cmd == 'open') {
 215                         return {
 216                                         cwd     : files[phash] || this.normalizeFile(data.cwd),
 217                                         files   : $.map(files, function(f) { return f }),
 218                                         options : self.normalizeOptions(data),
 219                                         init    : !!data.params,
 220                                         debug   : data.debug
 221                                 };
 222                 }
 223
 224
 225
 226                 return $.extend({
 227                         current : data.cwd.hash,
 228                         error   : data.error,
 229                         warning : data.warning,
 230                         options : {tmb : !!data.tmb}
 231                 }, this.fm.diff($.map(files, filter)));
 232
 233         }
 234
 235         /**
 236          * Convert old api tree into plain array of dirs
 237          *
 238          * @param  Object  root dir
 239          * @return Array
 240          */
 241         this.normalizeTree = function(root) {
 242                 var self     = this,
 243                         result   = [],
 244                         traverse = function(dirs, phash) {
 245                                 var i, dir;
 246
 247                                 for (i = 0; i < dirs.length; i++) {
 248                                         dir = dirs[i];
 249                                         result.push(self.normalizeFile(dir, phash))
 250                                         dir.dirs.length && traverse(dir.dirs, dir.hash);
 251                                 }
 252                         };
 253
 254                 traverse([root]);
 255
 256                 return result;
 257         }
 258
 259         /**
 260          * Convert file info from old api format into new one
 261          *
 262          * @param  Object  file
 263          * @param  String  parent dir hash
 264          * @return Object
 265          */
 266         this.normalizeFile = function(file, phash, tmb) {
 267                 var mime = file.mime || 'directory',
 268                         size = mime == 'directory' && !file.linkTo ? 0 : file.size,
 269                         info = {
 270                                 url    : file.url,
 271                                 hash   : file.hash,
 272                                 phash  : phash,
 273                                 name   : file.name,
 274                                 mime   : mime,
 275                                 date   : file.date || 'unknown',
 276                                 size   : size,
 277                                 read   : file.read,
 278                                 write  : file.write,
 279                                 locked : !phash ? true : file.rm === void(0) ? false : !file.rm
 280                         };
 281
 282                 if (file.mime == 'application/x-empty') {
 283                         info.mime = 'text/plain';
 284                 }
 285                 if (file.linkTo) {
 286                         info.alias = file.linkTo;
 287                 }
 288
 289                 if (file.linkTo) {
 290                         info.linkTo = file.linkTo;
 291                 }
 292
 293                 if (file.tmb) {
 294                         info.tmb = file.tmb;
 295                 } else if (info.mime.indexOf('image/') === 0 && tmb) {
 296                         info.tmb = 1;
 297
 298                 }
 299
 300                 if (file.dirs && file.dirs.length) {
 301                         info.dirs = true;
 302                 }
 303                 if (file.dim) {
 304                         info.dim = file.dim;
 305                 }
 306                 if (file.resize) {
 307                         info.resize = file.resize;
 308                 }
 309                 return info;
 310         }
 311
 312         this.normalizeOptions = function(data) {
 313                 var opts = {
 314                                 path          : data.cwd.rel,
 315                                 disabled      : data.disabled || [],
 316                                 tmb           : !!data.tmb,
 317                                 copyOverwrite : true
 318                         };
 319
 320                 if (data.params) {
 321                         opts.api      = 1;
 322                         opts.url      = data.params.url;
 323                         opts.archivers = {
 324                                 create  : data.params.archives || [],
 325                                 extract : data.params.extract || []
 326                         }
 327                 }
 328
 329                 if (opts.path.indexOf('/') !== -1) {
 330                         opts.separator = '/';
 331                 } else if (opts.path.indexOf('\\') !== -1) {
 332                         opts.separator = '\\';
 333                 }
 334                 return opts;
 335         }
 336
 337
 338 }