lanes 0.1.9.5 → 0.3.0

data/client/lanes/models/ServerCache.coffee

@@ -1,63 +1,78 @@
 class CacheEntry
 
-    constructor: (@collection, @options, @key) ->
-        @duration = Lanes.Vendor.Moment.duration(@collection.cacheDuration...)
-        _.bindAll(this, 'setFromServer')
-        @successCallback = @options.success
-        @options.success = this.setFromServer
-        Lanes.Models.Sync.perform('read', this, @options)
+    constructor: (timeout) ->
+        @duration = Lanes.Vendor.Moment.duration(timeout...)
+        @cache = {}
 
-    url: ->
-        _.result(@collection, 'url')
+    store: (record, key) ->
+        @cache[key] = {
+            data: record
+            at: Lanes.Vendor.Moment(new Date)
+        }
 
-    setFromServer: (reply, status, req) ->
-        if reply?.data?
-            Lanes.Models.ServerCache.store(@key, reply.data, @duration.asMilliseconds())
-        @successCallback?.apply(@options.scope, arguments)
-
-    # # needed to
-    # trigger: (type, model, xhr, options)->
-    #     @collection.trigger(type, @collection, xhr, options)
+    get: (key) ->
+        entry = @cache[key]
+        if entry
+            if entry.at.add(this.duration).isAfter(new Date)
+                return entry.data
+            else
+                delete @cache[key]
+        null
 
+computeCollectionCacheKey = (collection, options) ->
+    url = _.result(collection, "url")
+    query = {}
+    for key, value of options
+        query[ Lanes.Models.Sync.paramsMap[key] ] = value if Lanes.Models.Sync.paramsMap[key]
+    url + Lanes.lib.objToParam(query)
 
 Lanes.Models.ServerCache = {
-    CACHE: {}
-
-    store: (key, data, ms) ->
-        this.CACHE[key] = data
-        setTimeout(->
-            delete Lanes.Models.ServerCache.CACHE[key]
-        , ms)
-
-    computeCacheKey: (collection, options) ->
-        url = _.result(collection, "url")
-        query = {}
-        for key, value of options
-            query[ Lanes.Models.Sync.paramsMap[key] ] = value if Lanes.Models.Sync.paramsMap[key]
-        url + Lanes.lib.objToParam(query)
-
-    fetchRecord: (record, options) ->
+    MODELS: {}
+    COLLECTIONS: {}
+    PENDING: {}
+
+    storeRecordData: (key, records, timeout, pk) ->
+        cache = this.MODELS[key] ||= new CacheEntry(timeout)
+        for record in records
+            cache.store(record, record[pk])
+
+        ce = @COLLECTIONS[key] ||= new CacheEntry(timeout)
+        ce.store(records, key)
+
+
+    fetchRecord: (record, options = {}) ->
         key = record.urlRoot()
+        if (cache = this.MODELS[key])
+            if (data = cache.get(record.getId()))
+                record.setFromServer(data, options)
+                return _.Promise.resolve(record)
+
+        record.sync('read', record, options).then (record) ->
+            Lanes.Models.ServerCache.storeRecordData(
+                key, [record.toJSON()], record.cacheDuration, record.idAttribute
+            )
+            record
+
+    fetchCollection: (collection, options = {}) ->
+
+        key = computeCollectionCacheKey(collection, options)
+        if (cache = this.COLLECTIONS[collection.url()])
+
+            if (data = cache.get(key))
+                collection.setFromServer(data, options)
+                return _.Promise.resolve(collection)
+        @PENDING[key] ||= collection.sync('read', collection, options).then (collection) ->
+            Lanes.Models.ServerCache.storeRecordData(key,
+                collection.toJSON(),
+                collection.cacheDuration,
+                collection.model::idAttribute
+            )
+            delete Lanes.Models.ServerCache.PENDING[key]
+            collection
 
-        if data_set = this.CACHE[key]
-            found = false
-            for data in data_set
-                if record.id == data.id
-                    found = data
-                    break
-        if data_set && found
-            options.success.call(options.scope, {data: found}, "sucess", {})
-        else
-            this.sync('read', this, options)
-
-        false
-
-    fetchCollection: (collection, options) ->
-        key = this.computeCacheKey(collection, options)
-        if this.CACHE[key]
-            collection.setFromServer(this.CACHE[key], options)
-        else
-            new CacheEntry(collection, options, key)
-        return _.Promise.resolve(collection)
+            # ce = Lanes.Models.ServerCache.COLLECTIONS[key] ||= new CacheEntry(collection.cacheDuration)
+            # ce.store( collection.toJSON(), key)
+            # #ce.get( key )
+            # collection
 
 }

data/client/lanes/models/State.coffee

@@ -0,0 +1,97 @@
+class State
+    constructor: ->
+        super
+        @_bindEvent(eventSpec, fnName) for eventSpec, fnName of _.result(@, 'events', {})
+        @
+
+    _bindEvent: (eventSpec, fnName) ->
+        [kp, event] = eventSpec.split(' ')
+        unless event
+            event = kp; kp = ''
+        _.get(@, kp, @).on(event, @[fnName], @)
+
+
+    isState: true
+    dataTypes:
+        function:
+            set: (fn) ->
+                if _.isBlank(fn) or _.isFunction(fn)
+                    { val: fn, type: 'function' }
+                else
+                    throw new TypeError
+        element:
+            set: (el) ->
+                if _.isBlank(el) or _.isElement(el)
+                    { val: el, type: 'element' }
+                else
+                    throw new TypeError
+
+        collection:
+            set: (c) ->
+                if _.isBlank(c) or Lanes.u.isCollection(c) or _.isArray(c)
+                    { val: c, type: 'collection' }
+                else
+                    throw new TypeError
+        code:
+            set: (newVal) ->
+                newVal = '' if !newVal?
+                if _.isString(newVal)
+                    val: newVal.toUpperCase(), type: 'code'
+                else
+                    throw new TypeError('code must be a string')
+            default: -> ''
+        # Big decimal for attributes that need precision math
+        bigdec:
+            set: (newVal) ->
+                try
+                    val = _.bigDecimal(newVal)
+                    { val, type: 'bigdec' }
+                catch
+                    {val: newVal}
+            default: -> new _.bigDecimal(0)
+
+        integer:
+            set: (newVal) ->
+                val = parseInt(newVal, 10) unless _.isBlank(newVal)
+                {val, type: 'integer'}
+        file:
+            set: (val) ->
+                type = if _.isObject(val) then 'file' else typeof val
+                if _.isBlank(val)
+                    val = null
+                    type = 'file'
+                return { val, type }
+            default: -> {}
+
+        moment:
+            get: (val)    -> _.moment(val)
+            default:      -> _.moment()
+            set: (newVal) -> { val: _.moment(newVal), type: 'moment' }
+            compare: (currentVal, newVal) -> currentVal.isSame(newVal)
+
+        # Uses the "moment" lib to parse dates and coerce strings into the date type.
+        date:
+            get: (val) -> new Date(val)
+            default: -> return new Date()
+            set: (newVal) ->
+                if _.isDate(newVal)
+                    type = 'date'
+                    val = new Date(newVal)
+                else if newVal
+                    m = Lanes.Vendor.Moment(Date.parse(newVal))
+                    if m.isValid()
+                        type = 'date'
+                        val = m.toDate()
+                    else
+                        type = typeof newVal;
+                return { type, val }
+
+    # ## listenToAndRun
+    # Shortcut for registering a listener for a model
+    # and also triggering it right away.
+    listenToAndRun: (object, events, handler) ->
+        bound = _.bind(handler, this)
+        this.listenTo(object, events, bound)
+        bound()
+
+Lanes.Models.State = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.State, State )

data/client/lanes/models/Sync.coffee

@@ -30,18 +30,21 @@ Lanes.Models.Sync = {
     state: (method, model, options = {}) ->
         options.url ||= _.result(model, "url")
         if _.contains(['create', 'update', 'patch'], method)
-            options.data ||= model.dataForSave(options)
-        model.requestInProgress = true
-        model.trigger("request", model, options)
+            isSave = true
+            options.json ||= model.dataForSave(options)
+        model.requestInProgress = options
+        model.trigger("request", model, method, options)
         return new _.Promise (resolve, reject) ->
             handler = (reply) ->
                 delete model.requestInProgress
-                model.errors = reply?.errors
-                model.trigger("error", model, options) if reply.errors
-                model.lastServerMessage = reply?.message
-
+                model.lastServerMessage = reply.message
                 model.setFromServer(reply.data, options, method)
+                model.trigger("save", model, reply, options) if isSave
                 model.trigger("sync", model, reply, options)
+                if reply.errors
+                    Lanes.warn reply.errors
+                    model.errors = reply.errors
+                    model.trigger("error", model, options)
                 resolve(model)
 
             Lanes.Models.Sync.perform(method, options).then (reply) ->
@@ -64,18 +67,20 @@ Lanes.Models.Sync = {
         _.defaults(options, {
             method: methodMap[method]
             dataType: "json"
-            data: query
+            json: query
         })
 
         # Ensure that we have a URL.
-        url = options.url or Lanes.Models.Sync.urlError()
+        options.url or Lanes.Models.Sync.urlError()
         options.url += '.json'
         unless _.isEmpty(query)
             options.url += '?' + Lanes.lib.objToParam(query)
-        if options.data and !_.isString(options.data)
-            options.originalData = options.data
-            options.data = JSON.stringify( options.data )
+
+        # if options.data and !_.isString(options.data)
+        #     options.originalData = options.data
+        #     options.json = options.data
         options.headers ||= {}
+        # options.json = true
         options.headers['X_CSRF_TOKEN'] = Lanes.config.csrf_token
         options.contentType = "application/json"
 
@@ -86,7 +91,7 @@ Lanes.Models.Sync = {
                 if err
                     reject(error:err, body:options.xhr.responseText)
                 else
-                    resolve(JSON.parse(body))
+                    resolve(body)
             )
         )
 

data/client/lanes/models/index.js

@@ -3,6 +3,7 @@
 //= require ./ServerCache
 //= require ./AssociationMap
 //= require ./EnumMap
+//= require ./State
 //= require ./Base
 //= require ./Collection
 //= require_tree ./mixins

data/client/lanes/models/mixins/FileSupport.coffee

@@ -0,0 +1,60 @@
+isFileDefinition = (def) ->
+    (_.isString(def) and def is 'file') or (_.isObject(def) and def.type is 'file')
+
+Lanes.Models.Mixins.FileSupport = {
+
+    included: (klass) ->
+        files = _.pick klass::props, (def, name) -> isFileDefinition(def)
+        return if _.isEmpty(files)
+        session = {}
+        for name, def of files
+            session["#{name}_data"] = 'any'
+            session["#{name}_file"] = 'any'
+        _.extend( klass::session ||= {}, session)
+
+    initialize: ->
+        @on('save', @_uploadFileAfterSave)
+        for name, def of @_definition when isFileDefinition(def)
+            @on("change:#{name}_file", _.partial(@readPossibleImage, name))
+
+    hasImage: (attr) ->
+        this[attr] || this["#{attr}_data"]
+
+    imageUrlFor: (attr, type = '') ->
+        if this["#{attr}_data"]
+            this["#{attr}_data"]
+        else if (file = this[attr])
+            if type then file[type].url else file.url
+        else
+            ''
+
+    readPossibleImage: (name) ->
+        return unless (file = this["#{name}_file"])
+        reader = new FileReader()
+        reader.onloadend = =>
+            @["#{name}_data"] = reader.result
+        reader.readAsDataURL(file)
+
+
+    _uploadFileAfterSave: ->
+        files = _.pick @_definition, (def, name) =>
+            isFileDefinition(def) and @["#{name}_file"]
+        return if _.isEmpty(files)
+
+        form = new FormData()
+        for name, def of files
+            form.append("files[#{name}]", this["#{name}_file"], this["#{name}_file"].name)
+        form.append("type", @modelTypeIdentifier())
+        form.append("id", @getId())
+        form.append("extension_id", @FILE.extension.identifier)
+        url = Lanes.config.api_path + 'save-file-attribute'
+
+        Lanes.Vendor.xhr.post(url, {body: form}, (err, resp, body) =>
+            if err
+                @errors = { http: err.message }
+            else
+                model = JSON.parse(body)?.data?.model
+                @set(model)
+                this["#{name}_data"] = this["#{name}_file"] = null for name, def of files
+        )
+}

data/client/lanes/models/mixins/HasCodeField.coffee

@@ -1,13 +1,20 @@
+DEFAULT_INVALID = /[^A-Z0-9a-z]/
+
 Lanes.Models.Mixins.HasCodeField = {
 
-    INVALID: /[^A-Z0-9a-z]/
 
-    included: (klass)->
-        klass::INVALID_CODE_CHARS ||= Lanes.Models.mixins.Lanes.sCodeField.INVALID
+    included: (klass) ->
+        klass::INVALID_CODE_CHARS ||= DEFAULT_INVALID
 
     initialize: ->
-        this.on('change:code', this.upcaseCode)
+        this.on('change:code', this._cleanCodeAttr)
+
+    _cleanCodeAttr: ->
+        code = this.get('code')
+        return unless code
+        this.set(
+            'code', code.toUpperCase().replace(@INVALID_CODE_CHARS, '')
+        )
 
-    upcaseCode: ->
-        this.set('code', this.get('code').toUpperCase())
+    visibleIdentifier: -> @code
 }

data/client/lanes/models/query/ArrayResult.coffee

@@ -0,0 +1,188 @@
+class Page
+
+    constructor: (@pageNum, @result, options = {}) ->
+        query = {}
+        @rows = options.rows || []
+        return if options.rows
+
+        @result.query.clauses.each (clause) ->
+            _.extend( query, clause.toParam() ) if clause.isValid
+
+        options = {
+            format: 'array', total_count: 't'
+            start: @pageNum * @result.pageSize, limit: @result.pageSize,
+            query: query, url: @result.query.src::urlRoot(),
+            fields: _.pluck( @result.query.fields.where(query: true), 'id')
+        }
+        if @result.query.sortField
+            options.order = {}
+            {sortBy} = @result.query.sortField
+            field_name = if sortBy
+                if _.isFunction(sortBy) then @result.query.sortField.id else sortBy
+            else
+                @result.query.sortField.id
+            options.order[field_name] = if @result.query.sortAscending then 'asc' else 'desc'
+
+        _.extend(options, _.omit(@result.query.syncOptions, 'include'))
+        @result.query.trigger('request', @result.query, 'GET', {})
+        @result.requestInProgress = options
+        Lanes.Models.Sync.perform('GET', options).then (resp) =>
+            @result.total = resp.total
+            @rows  = resp.data
+            delete @result.requestInProgress
+            @result.onPageLoad(@)
+
+    _normalizedIndex: (index) ->
+        index = index % @result.pageSize
+
+    # N.B. for convenience the index for the methods below is the absolute index for all results
+    # not the index just for this page.  It's converted and the appropriate row returned
+    _rowAt: (index) ->
+        row = @rows[ @_normalizedIndex(index) ] || []
+
+    _rowToModel: (row) ->
+        attrs = {}
+        for field, i in @result.query.fields.models when field.query and row[field.fetchIndex]?
+            attrs[field.id] = row[field.fetchIndex]
+        new @result.query.src(attrs)
+
+    rowAt: (index) ->
+        @_rowAt(index)
+        # row = @_rowAt(index)
+        # @result.query.fields.map (field) =>
+        #     value = row[field.fetchIndex]
+        #     field.format?(value, row, @result.query) or value
+
+    modelAt: (index) ->
+        row = @_rowAt(index)
+        @modelCache ||= {}
+        id = @idForRow(row)
+        if _.isBlank(id)
+            @_rowToModel(row)
+        else
+            @modelCache[id] ||= @_rowToModel(row)
+
+    saveModelChanges: (model, index) ->
+        row = @_rowAt(index)
+        @modelCache[ @idForRow(row)] = model
+        data = model.serialize()
+        for field, i in @result.query.fields.models
+            row[field.fetchIndex] = data[field.id]
+
+    idForRow: (row) ->
+        row[@result.query.idIndex]
+
+    addBlankRow: (index) ->
+        model = new @result.query.model
+        row = []
+        for field, i in @result.query.fields.models
+            row[field.fetechIndex] = model[field.id]
+        @rows.splice(@_normalizedIndex(index), 0, row)
+        @_rowToModel(row)
+
+    removeRow: (index = 0) ->
+        @rows.splice(@_normalizedIndex(index), 1)
+
+class Lanes.Models.Query.ArrayResult extends Lanes.Models.Query.Result
+
+    constructor: (q, options = {}) ->
+        @query = q
+        @xDataColumn = @query.fields.where(query: true).length + 1
+        @pageSize = options.pageSize || 20
+        @pages = {}
+
+    reset: ->
+        @total = 0
+        @pages = {}
+
+    pageForIndex: (index) ->
+        pageNum = Math.floor(index / @pageSize)
+        @pages[pageNum] ||= new Page(pageNum, this)
+
+    visibleIndexes: ->
+        @_visibleIndexes ||= (
+            _.compact( @query.fields.map( (f, i) ->
+                if f.visible then i else null
+            ))
+        )
+
+    xtraData: (indexOrRow, options) ->
+        row = if _.isArray(indexOrRow) then indexOrRow else
+            @pageForIndex(indexOrRow).rowAt(indexOrRow)
+        row[@xDataColumn] ||= {}
+        _.extend(row[@xDataColumn], options) if options
+        row[@xDataColumn]
+
+    rowAt: (index, options = {}) ->
+        @pageForIndex(index).rowAt(index)
+
+    allRows: (options) ->
+        rows = (@rowAt(i, options) for i in [0...@length])
+        _.Promise.resolve(rows)
+
+    eachRow: (fn) ->
+        for i in [0...@length]
+            row = @rowAt(i)
+            fn(row, row[@xDataColumn], i)
+
+    map: (fn) ->
+        rows = []
+        @query.results.eachRow (row, xd, i) ->
+            rows.push fn(row, xd, i)
+        rows
+
+
+    filteredRows: (fn) ->
+        found = []
+        @eachRow (row, xd) ->
+            found.push(row) if fn(row, xd)
+        found
+
+    modelAt: (index) ->
+        @pageForIndex(index).modelAt(index)
+
+    saveModelChanges: (model, index) ->
+        @pageForIndex(index).saveModelChanges(model, index)
+
+    removeRow: (index = 0) ->
+        @total -= 1
+        @pageForIndex(index).removeRow(index)
+
+    addBlankRow: (index = 0) ->
+        @total += 1
+        @pageForIndex(index).addBlankRow(index)
+
+    ensureLoaded: (options = {}) ->
+        @pageForIndex(options.page || 0).pendingLoad or _.Promise.resolve(@)
+
+    reload: (options = {}) ->
+        @pages = []
+        @total = 0
+        @ensureLoaded(options)
+
+    onPageLoad: (page) ->
+        @query.trigger('load', @query)
+        @
+
+    rowRepresentation: (rowNum) ->
+        @pageForIndex(rowNum).rowAt(rowNum)
+
+    valueForField: (rowNum, field) ->
+        @rowAt(rowNum)[ field.fetchIndex ]
+
+    _updateSort: ->
+        fn = @sortingFunction()
+        if fn then @allRows().then (rows) =>
+            rows = _.sortBy(rows, _.bind(fn, @))
+            rows = if @query.sortAscending then rows.reverse() else rows
+            page = new Page(0, @, rows: rows)
+            @pages = [page]
+            @query.changeCount += 1
+            @
+        else
+            @reload().then =>
+                @query.changeCount += 1
+                @
+
+Object.defineProperty Lanes.Models.Query.ArrayResult.prototype, 'length',
+    get: -> @total || 0