lanes 0.1.9 → 0.1.9.5

data/client/lanes/models/PubSub.coffee

@@ -8,23 +8,29 @@ class ModelType extends Lanes.Models.State
         id: 'string'
         records: 'object'
 
-    subscribe: (model)->
-        channel = "/#{_.result(model,'api_path')}/#{model.id}"
-        Lanes.Vendor.MessageBus.subscribe(channel,(changes)->
-            model.addChangeSet(changes)
+    subscribe: (config) ->
+        model = config.models[0]
+        channel = "/#{_.result(model, 'api_path')}/#{model.id}"
+        Lanes.Vendor.MessageBus.subscribe(channel, (changes) ->
+            for model in config.models
+                model.addChangeSet(changes)
         )
         channel
 
-    add: (model)->
+    add: (model) ->
         if (config = @records[model.id])
-            config.model = model
+            config.models.push(model) unless _.include(config.models, model)
         else
-            @records[model.id] = { model: model, channel: this.subscribe(model) }
+            config = { models: [model] }
+            config.channel = this.subscribe(config)
+            @records[model.id] = config
 
-    remove: (model)->
+    remove: (model) ->
         if ( config = @records[model.id] )
-            Lanes.Vendor.MessageBus.unsubscribe( config.channel )
-        delete @records[model.id]
+            _.remove(config.models, (m) -> m == model)
+            if _.isEmpty(config.models)
+                Lanes.Vendor.MessageBus.unsubscribe( config.channel )
+                delete @records[model.id]
 
 
 class ModelTypesCollection extends Lanes.Models.BasicCollection
@@ -32,8 +38,8 @@ class ModelTypesCollection extends Lanes.Models.BasicCollection
     constructor: -> super
     model: ModelType
 
-    forModel: (model)->
-        path = _.result(model,'api_path')
+    forModel: (model) ->
+        path = _.result(model, 'api_path')
         models = this.get(path) || this.add(id: path)
 
 
@@ -41,24 +47,27 @@ Lanes.Models.PubSub = {
 
     types: new ModelTypesCollection
 
-    forModel: (model)->
+    # forModel: (model) ->
 
-    add: (model)->
+    add: (model) ->
         return unless model.isPersistent?()
         @types.forModel(model).add(model)
 
-    remove: (model)->
+    remove: (model) ->
         return unless model && model.isPersistent?()
         @types.forModel(model).remove(model)
 
-    instanceFor: ( model_klass, id )->
-        @types.get(_.result(model_klass.prototype,'api_path'))?.records[id]?.model
+    instanceFor: ( model_klass, id ) ->
+        path = _.result(model_klass.prototype, 'api_path')
+        @types.get(path)?.records[id]?.models[0]
 
     clear: ->
         @types = new ModelTypesCollection
 
     initialize: ->
         Lanes.Vendor.MessageBus.start()
-        Lanes.Vendor.MessageBus.callbackInterval = 500
-
+        Lanes.Vendor.MessageBus.callbackInterval = 2000
+        Lanes.Vendor.MessageBus.subscribe("/file-change", (changes) ->
+            Lanes.lib.HotReload.initiate(changes)
+        )
 }

data/client/lanes/models/Query.coffee

@@ -1,24 +1,32 @@
 class Field extends Lanes.Models.Base
 
-    constructor: (attributes)->
+    constructor: (attributes) ->
         super( _.defaults( attributes, {
-            title: _.titleize(attributes.id)
+            title: _.titleize(_.humanize(attributes.id))
         }))
 
     session:
         id:       'string'
         title:    'string'
+        visible:  type: 'boolean', default: true
         selected: 'boolean'
+        flex:     type: 'number',  default: 1
+        textAlign: type: 'string', default: 'left'
 
     derived:
+        default_value: deps: ['id'], fn: ->
+            switch @model_field.type
+                when 'integer' then 0
+                else ''
         model_field:
-            deps: ['id'], fn:->
+            deps: ['id'], fn: ->
                 this.collection.query.modelClass::_definition[@id]
         type:
             deps: ['model_field'], fn: ->
-                @model_field?.type
+                type = @model_field?.type || 'string'
+                if type == "code" then "string" else type
 
-    validValue: (value)->
+    validValue: (value) ->
         if this.type == 'n'
             ! _.isNaN( parseFloat(value) )
         else
@@ -27,17 +35,21 @@ class Field extends Lanes.Models.Base
 
 class AvailableFields extends Lanes.Models.Collection
 
-    constructor: (models,options)->
+    model: Field
+
+    constructor: (models, options) ->
         @query = options.query
+        this.on('change', (changing) ->
+            return unless changing.selected
+            for model in @models
+                model.selected = false unless model == changing
+        )
         super
-
-    model: Field
+        @visible = @subcollection(where: {visible: true})
 
 
 class Operator extends Lanes.Models.Base
 
-    addStandardProperties: Lanes.emptyFn
-
     session:
         id:       'string'
         name:     'string'
@@ -47,7 +59,7 @@ class Operator extends Lanes.Models.Base
 
     derived:
         valid:
-            deps: ['types','field']
+            deps: ['types', 'field']
             fn: ->
                 !this.types || ( this.field && _.contains(this.types, this.field.type) )
 
@@ -60,11 +72,15 @@ class Operators extends Lanes.Models.Collection
         this.add([
             { id: 'like', name: 'Starts With', types:['string'] }
             { id: 'eq',   name: 'Equals' }
-            { id: 'lt',   name: 'Less Than',   types:['integer','bigdec','number'] }
-            { id: 'gt',   name: 'More Than',   types:['integer','bigdec','number'] }
+            { id: 'lt',   name: 'Less Than',   types:['integer', 'bigdec', 'number'] }
+            { id: 'gt',   name: 'More Than',   types:['integer', 'bigdec', 'number'] }
         ])
-
-    setField: (field)->
+        this.on('change', (changing) ->
+            return unless changing.selected
+            for model in @models
+                model.selected = false unless model == changing
+        )
+    setField: (field) ->
         this.invoke('set', 'field', field)
         selected = this.findWhere(selected: true)
         if selected && !selected.valid
@@ -72,6 +88,7 @@ class Operators extends Lanes.Models.Collection
             this.findWhere(valid:true).selected = true
 
 
+
 class Clause extends Lanes.Models.Base
 
     session:
@@ -85,39 +102,40 @@ class Clause extends Lanes.Models.Base
             collection: AvailableFields, options: ->
                 query: this.collection.query
 
-
     derived:
         description:
-            deps: ['field','operator']
-            fn: -> "#{@field.title} #{@operator.id}"
+            deps: ['field', 'operator']
+            fn: -> "#{@field.title} #{@operator?.id}"
 
         isValid:
             deps: ['field', 'operator', 'value']
             fn: -> this.field.validValue(@value)
 
-    constructor: (options)->
+        query:
+            fn: -> @collection.query
+
+    constructor: (options) ->
         super
         this.fields.reset(options.available_fields.models)
         @operators.field = @fields.first()
         @fields.on('change:selected',    this.setField,    this)
         @operators.on('change:selected', this.setOperator, this)
 
-        @fields.at(0).selected = true
+        @fields.findWhere(visible: true)?.selected = true
         @operators.at(0).selected = true
 
-
-    setFromView: (type, val)->
-        if type=="fields" || type == "operators"
-            this[type].get(val).selected=true
+    setFromView: (type, val) ->
+        if type == "fields" || type == "operators"
+            this[type].get(val).selected = true
         else
             super
 
-    setField: (field)->
+    setField: (field) ->
         return unless field.selected
         @operators.setField( field )
         this.field = field
 
-    setOperator: (operator)->
+    setOperator: (operator) ->
         return unless operator.selected
         this.operator = operator
 
@@ -128,7 +146,7 @@ class Clause extends Lanes.Models.Base
         param = {}
         op = this.operator.id
         value = this.get('value')
-        value +='%' if 'like' == op
+        value += '%' if 'like' == op
         value = parseFloat(value) if @field.type == "n"
         param[ this.field.id ] = if 'eq' == op then value else { op: op, value: value }
         param
@@ -138,12 +156,11 @@ class Clauses extends Lanes.Models.Collection
 
     model: Clause
 
-    initialize:(models,options)->
+    initialize:(models, options) ->
         super
         @query = options.query
         @fields = options.query.fields
 
-
 class Lanes.Models.Query extends Lanes.Models.Base
 
     session:
@@ -151,44 +168,60 @@ class Lanes.Models.Query extends Lanes.Models.Base
         clauses: 'collection'
         modelClass:  'function'
         initialField: 'state'
+        idIndex: 'number'
+        initialFieldIndex: 'number'
+        pageSize: 'number'
 
     derived:
+        results:
+            fn: -> new Lanes.Models.QueryResults(this, pageSize: @pageSize)
         collection_class:
             deps:['modelClass'], fn: -> @modelClass?.Collection
         url:
             deps:['modelClass'], fn: -> @modelClass?::urlRoot()
 
-    constructor: (options={})->
+    constructor: (options = {}) ->
         super
-        @fields = new AvailableFields(
-            _.map( options.fields, (col)-> if _.isObject(col) then col else { id: col } ),
-            query: this
-        )
+        idName = @modelClass::idAttribute
+        @loadAssociations = options.loadAssociations
+        @fields = new AvailableFields([], query: this)
+        for col, i in options.fields
+            rec = if _.isObject(col) then col else { id: col }
+            @fields.add rec
+            @idIndex = i if rec.id == idName
+        unless @idIndex?
+            @idIndex = @fields.length
+            @fields.add(id: idName)
         @clauses = new Clauses([], query: this )
-        this.listenTo(@clauses,'change remove reset', ->
+        this.listenTo(@clauses, 'change remove reset', ->
+            @results.reset()
             this.trigger('change', arguments...)
         )
-        @initialField = @fields.first()
+        if @initialFieldIndex
+            @initialField = this.fields.at(@initialFieldIndex)
+        @initialField ||= this.fields.findWhere(id: "code") ||
+            this.fields.findWhere(id: "visibleId") ||
+            this.fields.first()
         this.addNewClause()
         this
 
+    execute: ->
+        this.trigger('execute')
+
     isValid: ->
         ! @clauses.findWhere( isValid: false )
 
-    loadSingle: (code,options)->
+    loadModelWithAssociations: (model) ->
+        model.withAssociations(@loadAssociations...)
+
+    loadSingle: (code, options = {}) ->
         options.query = {}
         options.query[ @initialField.id ] = code
+        options.include = @loadAssociations
         @modelClass.fetch(options)
 
     defaultField: ->
         @fields.findWhere( field: @initialField )
 
-    asParams: ->
-        params = {}
-        @clauses.each (clause)->
-            _.extend( params, clause.toParam() ) if clause.isValid
-
-        params
-
     addNewClause: ->
-        @clauses.add({ available_fields: @fields, field: @initialField })
+        @clauses.add(query: this, available_fields: @fields, field: @initialField)

data/client/lanes/models/QueryResults.coffee

@@ -0,0 +1,93 @@
+class Page
+
+    constructor: (@pageNum, @result, options = {}) ->
+        query = {}
+        @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.url,
+            fields: @result.query.fields.pluck('id')
+        }
+
+        Lanes.Models.Sync.perform('GET', options).then (resp) =>
+            @result.total = resp.total
+            @rows  = resp.data
+            delete @pending
+            @result.onPageLoad(@)
+
+    # 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) ->
+        index = index % @result.pageSize
+        @rows[index] || []
+
+    modelAt: (index) ->
+        row = @rowAt(index)
+        @modelCache ||= {}
+        @modelCache[ @idForRow(row)] ||= (
+            attrs = {}
+            for field, i in @result.query.fields.models
+                attrs[field.id] = row[i]
+            new @result.query.modelClass(attrs)
+        )
+
+    idForRow: (row) ->
+        row[@result.query.idIndex]
+
+
+
+class Lanes.Models.QueryResults
+
+    constructor: (q, options = {}) ->
+        @cid = _.uniqueId()
+        @query = q
+        @pageSize = options.pageSize || 20
+        @pages = {}
+
+    reset: ->
+        @pages = {}
+
+    pageForIndex: (index) ->
+        pageNum = Math.floor(index / @pageSize)
+        @pages[pageNum] ||= new Page(pageNum, this)
+
+    rowAt: (index, options = {}) ->
+        row = @pageForIndex(index).rowAt(index)
+        if options.visibleOnly
+            @visibleIndexes ||= _.compact @query.fields.map (f, i) -> if f.visible then i else null
+            row[fieldIndex] for fieldIndex in @visibleIndexes
+        else
+            row
+
+    modelAt: (index) ->
+        @pageForIndex(index).modelAt(index)
+
+
+    saveModelChanges: (model) ->
+        page = @pageForIndex
+        @_calculateCache() unless @idCache
+        row = @idCache[model.id]
+        for field, i in @query.fields.models
+            row[i] = model[field.id]
+        model
+
+    addBlankRow: ->
+        model = new @query.modelClass()
+        row = []
+        for field, i in @query.fields.models
+            row[i] = model[field.id]
+        @rows.unshift row
+
+    ensureLoaded: ->
+        @pageForIndex(0) if _.isEmpty(@pages)
+        return null
+
+    onPageLoad: (page) ->
+        @query.trigger('load', @query)
+
+
+Object.defineProperty Lanes.Models.QueryResults.prototype, 'length',
+    get: -> @total || 0

data/client/lanes/models/ServerCache.coffee

@@ -1,16 +1,16 @@
 class CacheEntry
 
-    constructor: (@collection, @options, @key)->
+    constructor: (@collection, @options, @key) ->
         @duration = Lanes.Vendor.Moment.duration(@collection.cacheDuration...)
-        _.bindAll(this,'setFromServer')
+        _.bindAll(this, 'setFromServer')
         @successCallback = @options.success
         @options.success = this.setFromServer
         Lanes.Models.Sync.perform('read', this, @options)
 
     url: ->
-        _.result(@collection,'url')
+        _.result(@collection, 'url')
 
-    setFromServer: (reply, status, req)->
+    setFromServer: (reply, status, req) ->
         if reply?.data?
             Lanes.Models.ServerCache.store(@key, reply.data, @duration.asMilliseconds())
         @successCallback?.apply(@options.scope, arguments)
@@ -23,23 +23,23 @@ class CacheEntry
 Lanes.Models.ServerCache = {
     CACHE: {}
 
-    store: (key, data, ms)->
+    store: (key, data, ms) ->
         this.CACHE[key] = data
         setTimeout(->
             delete Lanes.Models.ServerCache.CACHE[key]
         , ms)
 
-    computeCacheKey: (collection, options)->
+    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.$.param(query)
+        url + Lanes.lib.objToParam(query)
 
-    fetchRecord: (record, options)->
+    fetchRecord: (record, options) ->
         key = record.urlRoot()
 
-        if data_set=this.CACHE[key]
+        if data_set = this.CACHE[key]
             found = false
             for data in data_set
                 if record.id == data.id
@@ -52,12 +52,12 @@ Lanes.Models.ServerCache = {
 
         false
 
-    fetchCollection: (collection, options)->
+    fetchCollection: (collection, options) ->
         key = this.computeCacheKey(collection, options)
         if this.CACHE[key]
             collection.setFromServer(this.CACHE[key], options)
-            options.success.call(options.scope, {data: this.CACHE[key]}, "sucess", {})
         else
-            new CacheEntry(collection,options, key)
+            new CacheEntry(collection, options, key)
+        return _.Promise.resolve(collection)
 
 }