lanes 0.0.1

data/client/javascripts/data/Model.coffee

@@ -0,0 +1,269 @@
+class DataModel
+    isModel: true
+
+    constructor: (attrs,options)->
+        this._unsaved = if attrs then _.keys(attrs) else []
+        super
+        this.on('change', this._recordUnsaved )
+
+    session:
+        errors: 'object'
+        changes: { type: 'collection', setOnce: true }
+        lastServerMessage: { type: 'string' }
+
+    derived:
+        error_message:
+            deps:['errors'], fn: ->
+                if !@errors then ''
+                else if @errors.exception then @errors.exception
+                else  _.toSentence( _.map(@errrors, (value,key)-> "#{key}: #{value}" ) )
+
+    dataTypes:
+        bigdec:
+            set: (newVal)->
+                val: new _.bigDecimal(newVal)
+                type: 'bigdec'
+            default: -> new _.bigDecimal(0)
+        integer:
+            set: (newVal)->
+                val: parseInt(newVal)
+                type: 'integer'
+        date:
+            get: (val)-> new Date(val)
+            default: -> return new Date()
+            set: (newVal)->
+                if _.isDate(newVal)
+                    newType='date'
+                    newVal = newVal.valueOf();
+                else
+                    m=Lanes.Vendor.Moment(newVal)
+                    if m.isValid()
+                        newType='date'
+                        newVal=m.toDate()
+                    else
+                        newType = typeof newVal;
+                return {
+                    val: newVal,
+                    type: newType
+                }
+
+    modelForAccess: -> this
+
+    isPersistent: ->
+        !!( this.api_path && ! this.isNew() )
+
+    addChangeSet: (change)->
+        this.changes ||= new Lanes.Data.ChangeSetCollection( parent: this )
+        change.record = this
+        change = this.changes.add(change)
+        this.set( change.value() )
+
+    rootRecord: ->
+        record = this.parent
+        while record
+            if record.parent then record = record.parent else break
+        record
+
+    urlRoot: ->
+        Lanes.Data.Config.api_path + '/' + @resultsFor('api_path')
+
+    setupStandardProps: -> Lanes.emptyFn
+
+    isLoaded: ->
+        !_.isEmpty( _.omit(this.attributes,this.idAttribute) )
+
+    withAssociations: (names...,options={})->
+        scope = options.scope || this
+        if _.isString(options)
+            names.push(options); options={}
+        needed = _.filter( names, (name)->
+            this._associations[name] && ! this._associations[name].instance(this).isLoaded()
+        ,this)
+        if _.isEmpty( needed )
+            options.success.call(scope, this  ) if options.success
+            options.complete.call(scope,this  ) if options.complete
+            return Lanes.Promise.resolve(this)
+        else
+            options['include']=needed
+            this.fetch(options)
+                .then (req)-> req.record
+
+    @findOrCreate: (attrs, options={})->
+        if attrs.id && ( record = Lanes.Data.PubSub.instanceFor(this, attrs.id) )
+            record.set(attrs)
+        else
+            new this(attrs,options)
+
+    @fetch: (options)->
+        record = new this()
+        if _.isNumber(options)
+            record.id = options
+            options = {}
+        ret = record.fetch(options)
+        ret
+
+    fetch: (options={})->
+        handlers = wrapRequest(this,options)
+        super(_.extend(options,{limit:1,ignoreUnsaved:true})).then( =>@ )
+        handlers.promise
+
+    parse:(resp)->
+        if resp.data
+            if _.isArray(resp['data']) then resp['data'][0] else resp['data']
+        else
+            resp
+
+    set: (attrs,options)->
+        super
+        if _.isObject(attrs) && ! options?.saving
+            for name, association of this._associations||{}
+                association.instance(this).set(attrs[association.name], options) if attrs[association.name]
+        this
+
+    save: (options={})->
+        options.setFromResponse=true
+        options.saving=true
+        handlers = wrapRequest(this,options)
+        super({}, options)
+        handlers.promise
+
+    dataForSave: (options={})->
+        if options.saveAll
+            data = @attributes
+        else
+            data = this.unsavedData()
+        for name, association of this._associations||{}
+            if association.isCreated(this) && association.instance(this).isDirty()
+                instance = association.instance(this)
+                data[association.name] = if options.saveAll then instance.attributes else instance.unsavedData()
+        data
+
+    destroy: (options={})->
+        handlers = wrapRequest(this,options)
+        super(options)
+        handlers.promise
+
+    unsavedData: ->
+        attrs = if this.isNew() then {} else { id: this.getId() }
+        _.extend(attrs, _.pick( this.attributes, @_unsaved... ) )
+
+    isDirty:->
+          !!@_unsaved.length
+
+    hasAttribute: (name)->
+        !!this._definition[name]
+
+    associationDefinition: (name,options)->
+        _.extend(options, {
+            fk: options.fk || name + "_id"
+            name: name
+            isCreated: (parent)->
+                parent._cache.hasOwnProperty(@name)
+            instance:  (parent)-> parent[@name]
+        })
+
+
+    associationDerivedDefinition: (name,definition)->
+        klass = associationLookupClass(definition)
+        {
+            deps: [definition.fk]
+            fn: ->
+                args = {}
+                args['id'] = this.get(definition.fk) if this.get(definition.fk)
+                if definition.defaultValue
+                    _.defaults(args, _.evaluateFunction(definition.defaultValue))
+                klass ||= associationLookupClass(definition)
+                record = klass.findOrCreate(args)
+                record.parent = this
+                record
+        }
+
+    validateFieldChange: (name, value)->
+        return '' unless def = this._definition[name]
+        if def.required && _.isEmpty(value)
+            "Cannot be empty"
+        else
+            ''
+
+    sync: ->
+        Lanes.Data.Sync.apply(this,arguments)
+
+    _recordUnsaved: (record,options)->
+        attrs = this.changedAttributes()
+        unless options?.silent || options?.ignoreUnsaved
+            for name,val of attrs
+                @_unsaved.push( name ) if -1 == @_unsaved.indexOf(name)
+        this
+
+
+    @extended: (klass)->
+        klass.prototype.props        ||= {}
+        klass.prototype.session      ||= {}
+        klass.prototype.associations ||= {}
+        (klass.prototype.addStandardProperties || setupStandardProps).call(klass, klass.prototype)
+
+        setupAssociations(klass.prototype) if klass.prototype.associations
+
+
+    Lanes.lib.ModuleSupport.includeInto(@)
+    @include Lanes.lib.results
+
+
+associationLookupClass = (definition)->
+    object = definition.model || definition.collection
+    if _.isObject(object) then object else Lanes.getPath( object, "Lanes.Data")
+
+setupAssociations=(klass)->
+    klass.derived     ||= {}
+    klass._associations = {}
+    derivedFn = ( klass.associationDerivedDefinition || DataModel.prototype.associationDerivedDefinition )
+    createFn  = ( klass.associationDefinition        || DataModel.prototype.associationDefinition)
+    for name, options of klass.associations
+        definition = createFn.call(klass, name, options)
+        klass.derived[ name ] = derivedFn.call(klass, name, definition)
+        klass._associations[name] = definition
+
+setupStandardProps=(klass)->
+    klass.session['created_at'] ||= 'date'
+    klass.session['updated_at'] ||= 'date'
+    klass.associations['created_by'] ||= { model: 'Lanes.Data.User' }
+    klass.associations['updated_by'] ||= { model: 'Lanes.Data.User' }
+
+copyServerResp = (record,resp)->
+    record.errors = resp.errors
+    record.lastServerMessage = resp.message
+    { record: record, response: resp }
+
+wrapRequest = (record, options)->
+    error   = options.error
+    success = options.success
+    options.promise = new Lanes.Promise( (resolve,reject)->
+        options.resolvePromise = resolve
+        options.rejectPromise  = reject
+    )
+    options.error = (record, resp, req)->
+        options.rejectPromise( copyServerResp(record,resp.responseJSON) )
+        error?.apply(options.scope, arguments)
+
+    options.success = (record,resp,req)->
+        options.resolvePromise( copyServerResp(record,resp) )
+        record._unsaved = []
+        success?.apply(options.scope, arguments)
+    options
+
+
+Lanes.Data.Model = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.Model, DataModel )
+
+
+class BasicModel
+    constructor: -> super
+    isPersistent: -> false
+    isModel: true
+
+Lanes.Data.BasicModel = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.Model, BasicModel )
+
+
+class State
+    constructor: -> super
+
+Lanes.Data.State = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.State, State )

data/client/javascripts/data/PubSub.coffee

@@ -0,0 +1,68 @@
+MB = Lanes.Vendor.MessageBus
+
+class ModelType
+    constructor: ->
+        super
+        @records = {}
+
+    session:
+        id: 'string'
+        records: 'object'
+
+    subscribe: (model)->
+        channel = "/#{model.api_path}/#{model.id}"
+        MB.subscribe(channel,(changes)->
+            model.addChangeSet(changes)
+        )
+        channel
+
+    add: (model)->
+        if (config = @records[model.id])
+            config.model = model
+        else
+            @records[model.id] = { model: model, channel: this.subscribe(model) }
+
+    remove: (model)->
+        if ( config = @records[model.id] )
+            MB.unsubscribe( config.channel )
+        delete @records[model.id]
+
+
+Lanes.Data.State.extend(ModelType)
+
+class ModelTypesCollection
+    constructor: -> super
+    model: ModelType
+
+    forModel: (model)->
+        models = this.get(model.api_path) || this.add(id: model.api_path)
+
+Lanes.Data.BasicCollection.extend(ModelTypesCollection)
+
+
+
+Lanes.Data.PubSub = {
+
+    types: new ModelTypesCollection
+
+    forModel: (model)->
+
+    add: (model)->
+        return unless model.isPersistent()
+        @types.forModel(model).add(model)
+
+    remove: (model)->
+        return unless model && model.isPersistent()
+        @types.forModel(model).remove(model)
+
+    instanceFor: ( model_klass, id )->
+        @types.get(model_klass.prototype.api_path)?.records[id]?.model
+
+    clear: ->
+        @types = new ModelTypesCollection
+
+    initialize: ->
+        MB.start()
+        MB.callbackInterval = 500
+
+}

data/client/javascripts/data/Query.coffee

@@ -0,0 +1,184 @@
+class Field extends Lanes.Data.Model
+
+    constructor: (attributes)->
+        super( _.defaults( attributes, {
+            title: _.titleize(attributes.field)
+        }))
+
+    session:
+        title:    'string'
+        field:    'string'
+        selected: 'boolean'
+        type:
+            type: 'string'
+            default: -> @model_field?.type
+
+    derived:
+        model_field:
+            deps: ['field'], fn:->
+                this.collection.query.model_class::_definition[@field]
+
+    validValue: (value)->
+        if this.type == 'n'
+            ! _.isNaN( parseFloat(value) )
+        else
+            value
+
+
+class AvailableFields extends Lanes.Data.Collection
+
+    constructor: (models,options)->
+        @query = options.query
+        super
+    model: Field
+
+
+
+class Operator extends Lanes.Data.Model
+
+    addStandardProperties: Lanes.emptyFn
+
+    session:
+        id:       'string'
+        name:     'string'
+        types:    'array'
+        field:    'object'
+        selected: 'boolean'
+
+    derived:
+        valid:
+            deps: ['types','field']
+            fn: ->
+                !this.types || ( this.field && _.contains(this.types, this.field.type) )
+
+
+class Operators extends Lanes.Data.Collection
+    model: Operator
+
+    constructor: ->
+        super
+        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'] }
+        ])
+
+    setField: (field)->
+        this.invoke('set', 'field', field)
+        selected = this.findWhere(selected: true)
+        if selected && !selected.valid
+            selected.selected = false
+            this.findWhere(valid:true).selected = true
+
+
+class Clause extends Lanes.Data.Model
+
+    session:
+        value     : { type: 'string', default: '' }
+        operators : 'collection'
+        field     : 'model'
+        operator  : 'model'
+
+    derived:
+        description:
+            deps: ['field','operator']
+            fn: -> "#{@field.title} #{@operator.id}"
+
+        isValid:
+            deps: ['field', 'operator', 'value']
+            fn: -> this.field.validValue(@value)
+
+    initialize:(attrs,options)->
+        super
+        @operators = new Operators
+        @fields    = @collection.fields
+        @operators.field = @fields.first()
+        @fields.on('change:selected',    this.setField,    this)
+        @operators.on('change:selected', this.setOperator, this)
+
+        @fields.at(0).selected = true
+        @operators.at(0).selected = true
+
+        window.q = this
+
+    setField: (field)->
+        return unless field.selected
+        @operators.setField( field )
+        this.field = field
+
+    setOperator: (operator)->
+        return unless operator.selected
+        this.operator = operator
+
+    remove: ->
+        @collection.remove(this)
+
+    toParam: ->
+        param = {}
+        op = this.operator.id
+        value = this.get('value')
+        value +='%' if 'like' == op
+        value = parseFloat(value) if @field.type == "n"
+        param[ this.field.field ] = if 'eq' == op then value else { op: op, value: value }
+        param
+
+
+class Clauses extends Lanes.Data.Collection
+
+    model: Clause
+
+    initialize:(models,options)->
+        super
+        @query = options.query
+        @fields = options.query.fields
+
+
+class Lanes.Data.Query extends Lanes.Data.Model
+
+    session:
+        fields:  'collection'
+        clauses: 'collection'
+        collection_class: 'function'
+        initial_field: 'string'
+
+    derived:
+        model_class:
+            deps:['collection_class'], fn: -> @collection_class::model
+        url:
+            deps:['collection_class'], fn: -> @collection_class::url()
+
+    constructor: (options={})->
+        super
+        @fields = new AvailableFields(
+            _.map( options.fields, (col)-> if _.isObject(col) then col else { field: col } ),
+            query: this
+        )
+        @clauses = new Clauses([], query: this )
+        this.listenTo(@clauses,'change remove reset', ->
+            this.trigger('change', arguments...)
+        )
+        @initial_field = @fields.first.field
+        this.addNewClause()
+        this
+
+    isValid: ->
+        ! @clauses.findWhere( isValid: false )
+
+    loadSingle: (code,options)->
+        options.query = {}
+        options.query[ @initial_field ] = code
+        @collection_class::model.fetch(options)
+
+    defaultField: ->
+        @fields.findWhere( field: @initial_field )
+
+    asParams: ->
+        params = {}
+        @clauses.each (clause)->
+            _.extend( params, clause.toParam() ) if clause.isValid
+
+        params
+
+    addNewClause: ->
+        @clauses.add({ field: @initial_field, operator: 'like' })

data/client/javascripts/data/Roles.coffee

@@ -0,0 +1,91 @@
+class Role extends Lanes.Data.BasicModel
+    props:
+        id:     'string'
+        name:   'string'
+        member: { type: 'boolean', default: false }
+
+
+class Lanes.Data.Roles extends Lanes.Data.BasicCollection
+    model: Role
+    comparator: 'name'
+
+
+class RoleExtension extends Lanes.Extension.Base
+    identifier: 'roles'
+    setBootstrapData: (data)->
+        Lanes.Data.Roles.all = new Lanes.Data.Roles(
+            _.map( data, (role)->
+                { id: role.toLowerCase(), name: role }
+            )
+        )
+
+
+class UserRole
+    constructor: (config={})->
+        @type = config.type
+        for method in RWD
+            this[method] = _.map(config[method],klassFor)
+
+    can: (type,model)->
+        -1 != this[type].indexOf(model)
+
+
+RWD = ['read','write','delete']
+
+RoleMap = {
+    administrator: Administrator
+}
+
+# The admin is special and can do anything
+class Administrator
+    constructor: ->
+        UserRole.prototype.constructor.apply(this,arguments)
+    can: -> true
+
+
+
+class Lanes.Data.UserRoleSet
+
+    constructor: (access={})->
+        _.defaults(access, { roles: [], locked_fields: [] })
+        @roles = []
+        for role in access.roles
+            klass = RoleMap[role.type] || UserRole
+            @roles.push( new klass(role) )
+        @locked_fields = {}
+        for lock in access.locked_fields
+            if klass = klassFor(lock.type)
+                @locked_fields[ klass ] = locks = {}
+                locks[field] = grants for field, grants of lock.locks
+
+    can:(method,model,field)->
+        if model instanceof Lanes.Data.Model
+            model = model.constructor
+
+        if field && ( locks = @locked_fields[model] ) && ( grants = locks[field] )
+            for grant in grants
+                if grant.only && grant.only != method
+                    return this.testModelAccess(method,model)
+                else
+                    for role in @roles
+                        return true if role.type == grant.role
+            return false
+        else
+            return this.testModelAccess(method,model)
+
+    testModelAccess:(method,model)->
+        !!_.detect( @roles, (role)->role.can(method,model) )
+
+    canRead:(model,field)->
+        this.can('read',model,field)
+
+    canWrite:(model,field)->
+        this.can('write',model,field)
+
+    canDelete:(model)->
+        this.can('delete',model)
+
+klassFor = (identifier)->
+    name = _.chain(identifier).titleize().gsub(' ','').value()
+    Lanes.Data[name] ||
+        Lanes.warn("Role Data object not found for #{identifier}")