lanes 0.1.9 → 0.1.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ed648a6329d1d1b0c9ee0e5df25d1c184b5f5e0
-  data.tar.gz: 023a41ef58e894aa882ae712edb9a77b12d57d73
+  metadata.gz: f9ee3d792d48f1c5052df8f8def69d9b41feb772
+  data.tar.gz: 65421bc19936cb0890bf8309ca3496e9088a46c8
 SHA512:
-  metadata.gz: b6cfb3a4c38ec8dd175c17047aafc03ced98e6d30ce04e48f5bd5b2550aa88521cad0ac12252a00dfdaacff9c606bd68f5d3bdccf8b5882e7b396e16c2f189e6
-  data.tar.gz: 8befe413cd47f78796a50d344ffcd89e7021ad7d4541889a67d483b0a02c41bda1b6335de7c3263a00d30124b68dc1cd091e793ceacb9c030ed695943da95468
+  metadata.gz: 7af3b91f0c5a4a899ce73523d7723b1ae360de9550a0e6146207247545d2a2f4e6f011396d9ab4fd21b0632fde382445b284aba1f653656af8aa1b9144b9ab8f
+  data.tar.gz: f7d0b171766d83f2b6253a4c702a9d4a9b1b66ec32bad409c2519f14230e832cc14a106c858a5ca517b56696ffe7e16181bd14bebe0d4cfc0ab1f055b0dfbd74

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 *.rbc
+.DS_Store
 .bundle
 .config
 .yardoc

data/client/lanes/Boot.cjsx

@@ -0,0 +1,9 @@
+Lanes.renderScreenTo = (selector, options) ->
+    Lanes.config.set(options)
+    Lanes.Models.Bootstrap.initialize(options)
+    document.addEventListener "DOMContentLoaded", ->
+        viewport = new Lanes.React.Viewport(selector: selector)
+        Lanes.Models.PubSub.initialize()
+        Lanes.Extensions.fireOnInitialized(viewport)
+        Lanes.React.runRouter(viewport)
+        Lanes.Extensions.fireOnAvailable(viewport)

data/client/lanes/access/Extension.coffee

@@ -2,13 +2,27 @@ class Lanes.Access.Extension extends Lanes.Extensions.Base
 
     identifier: "lanes-access"
 
-    setBootstrapData: (data)->
+    setBootstrapData: (data) ->
+        Lanes.Models.Role.all = new Lanes.Models.Role.Collection( data.roles )
         Lanes.current_user = new Lanes.Models.User
-        Lanes.Models.Roles.all = new Lanes.Models.Roles( data.roles )
         if data.user
             Lanes.current_user.set(data.user)
         if data.access
             Lanes.current_user.access_data = data.access
 
-    onAvailable: (view)->
-        Lanes.Access.createLoginDialog(view)
+    showLogin: ->
+        Lanes.Workspace.Extension.uistate.modalDialog = Lanes.Access.LoginDialog.instance()
+
+    hideLogin: ->
+        Lanes.Workspace.Extension.uistate.modalDialog = null
+
+    onAvailable: (viewport) ->
+        @viewport = viewport
+        Lanes.current_user.on('change:isLoggedIn', =>
+            if Lanes.current_user.isLoggedIn
+                @hideLogin()
+            else
+                @showLogin()
+        )
+        unless Lanes.current_user.isLoggedIn
+            @showLogin()

data/client/lanes/access/LoginDialog.cjsx

@@ -0,0 +1,78 @@
+class Session extends Lanes.Models.Base
+    api_path: 'user-session'
+    props:
+        id:         'integer'
+        login:      'string'
+        password:   'string'
+        access:     'object'
+        user:       'object'
+
+
+class Lanes.Access.LoginDialog extends Lanes.React.Component
+
+    mixins: [
+        Lanes.React.Mixins.RelayEditingState
+    ]
+
+    getDefaultProps: ->
+        writable: true, editOnly: true
+
+    dataObjects: ->
+        model: new Session
+
+    login: ->
+        @model.save().then =>
+            Lanes.current_user.setLoginData(@model.user, @model.access) if @model.user
+
+    warning: ->
+        <BS.Alert bsStyle='warning'>
+             <strong>{@model.lastServerMessage}</strong>
+        </BS.Alert>
+
+    render: ->
+        <LC.Modal title='Please log in'
+            backdrop={false}
+            closeButton=false
+            animation={false}>
+
+            <div className='modal-body'>
+
+                {@warning() if @state?.hasError}
+
+                <BS.Row>
+                    <BS.Col mdOffset={2} xs={12} md={8}>
+
+                        <LC.TextField
+                            model={@model}
+                            autoFocus writable
+                            name="login"
+                            label='Username'
+                            placeholder='Enter Login'
+                        />
+
+                        <LC.TextField
+                            writable
+                            model={@model}
+                            name="password"
+                            type='password'
+                            label='Password'
+                            placeholder='Enter Password'
+                        />
+
+                    </BS.Col>
+                </BS.Row>
+            </div>
+
+
+            <div className='modal-footer'>
+                <BS.Button onClick={@login} bsStyle='primary'>Login</BS.Button>
+            </div>
+
+        </LC.Modal>
+
+
+
+# Function that returns a factory (or function) for the LoginDialog.
+# Intended as an extension point for other users to override if needed
+Lanes.Access.LoginDialog.instance = ->
+    @cache ||= React.createFactory(Lanes.Access.LoginDialog)

data/client/lanes/access/Roles.coffee

@@ -1,39 +1,33 @@
-class Role extends Lanes.Models.BasicModel
+class Lanes.Models.Role extends Lanes.Models.Base
     props:
         id:     'string'
         name:   'string'
         member: { type: 'boolean', default: false }
 
-
-class Lanes.Models.Roles extends Lanes.Models.BasicCollection
-    model: Role
-    comparator: 'name'
-
-
 class UserRole
-    constructor: (config={})->
+    constructor: (config = {}) ->
         @type = config.type
         for method in RWD
-            this[method] = _.map(config[method],klassFor)
+            this[method] = _.map(config[method], klassFor)
 
-    can: (type,model)->
+    can: (type, model) ->
         -1 != this[type].indexOf(model)
 
-    decodeLockedFields: (fields, previous={})->
+    decodeLockedFields: (fields, previous = {}) ->
         decoded = _.extend({}, previous)
         for lock in fields
             if klass = klassFor(lock.type)
-                decoded[ klass ] = locks = {}
+                decoded[ klass::api_path() ] = locks = {}
                 locks[field] = grants for field, grants of lock.locks
         decoded
 
-RWD = ['read','write','delete']
+RWD = ['read', 'write', 'delete']
 
 
 # The admin is special and can do anything
 class Administrator
     constructor: ->
-        UserRole.prototype.constructor.apply(this,arguments)
+        UserRole.prototype.constructor.apply(this, arguments)
     can: -> true
 
     decodeLockedFields: ->
@@ -46,7 +40,7 @@ RoleMap = {
 
 class Lanes.Models.UserRoleSet
 
-    constructor: (access={})->
+    constructor: (access = {}) ->
         _.defaults(access, { roles: [], locked_fields: [] })
         @roles = []
         @locked_fields = {}
@@ -56,33 +50,33 @@ class Lanes.Models.UserRoleSet
             @roles.push( role )
             @locked_fields = role.decodeLockedFields(access.locked_fields, @locked_fields)
 
-    can:(method,model,field)->
+    can: (method, model, field) ->
         if model instanceof Lanes.Models.Base
             model = model.constructor
 
-        if field && ( locks = @locked_fields[model] ) && ( grants = locks[field] )
+        if field && ( locks = @locked_fields[model::api_path()] ) && ( grants = locks[field] )
             for grant in grants
                 if grant.only && grant.only != method
-                    return this.testModelAccess(method,model)
+                    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)
+            return this.testModelAccess(method, model)
 
-    testModelAccess:(method,model)->
-        !!_.detect( @roles, (role)->role.can(method,model) )
+    testModelAccess:(method, model) ->
+        !!_.detect( @roles, (role) -> role.can(method, model) )
 
-    canRead:(model,field)->
-        this.can('read',model,field)
+    canRead:(model, field) ->
+        this.can('read', model, field)
 
-    canWrite:(model,field)->
-        this.can('write',model,field)
+    canWrite:(model, field) ->
+        this.can('write', model, field)
 
-    canDelete:(model)->
-        this.can('delete',model)
+    canDelete:(model) ->
+        this.can('delete', model)
 
-klassFor = (identifier)->
+klassFor = (identifier) ->
     Lanes.u.getPath(identifier) ||
         Lanes.warn("Model #{identifier} not found for role")

data/client/lanes/access/User.coffee

@@ -1,10 +1,10 @@
 class Lanes.Models.User extends Lanes.Models.Base
 
-    constructor: (attributes,access)->
+    constructor: (attributes, access) ->
         super
         this.access_data = access
 
-    api_path: 'users'
+    api_path: -> 'users'
     derived:
         roles:
             deps: ['role_names', 'access_data']
@@ -14,9 +14,9 @@ class Lanes.Models.User extends Lanes.Models.Base
         allRoles:
             deps: ['role_names', 'access_data']
             fn: ->
-                role_data = Lanes.Models.Roles.all?.toJSON() || []
-                roles = new Lanes.Models.Roles( role_data )
-                _.each( this.role_names, (name)->
+                role_data = Lanes.Models.Role.all?.toJSON() || []
+                roles = new Lanes.Models.Role.Collection( role_data )
+                _.each( this.role_names, (name) ->
                     roles.get(name)?.member = true
                 )
                 roles
@@ -33,34 +33,34 @@ class Lanes.Models.User extends Lanes.Models.Base
         options:     'object'
         password:    'string'
 
-    canRead: (model,field)  -> this.roles.canRead(model,field)
-    canWrite: (model,field) -> this.roles.canWrite(model,field)
-    canDelete: (model)      -> this.roles.canDelete(model)
+    canRead: (model, field)  -> this.roles.canRead(model, field)
+    canWrite: (model, field) -> this.roles.canWrite(model, field)
+    canDelete: (model)       -> this.roles.canDelete(model)
 
     logout: ->
+        return unless @isLoggedIn
         session = new Session( id: this.id )
         session
             .destroy()
             .then =>
-                _.each(@attributes, (value,key)=> @set(key, null) )
+                @access_data = []
+                @role_names  = []
+                _.each(@attributes, (value, key) => @set(key, null) )
 
-    setLoginData: (attrs, access)->
+    setLoginData: (attrs, access) ->
         this.access_data = access
         this.set(attrs)
 
-    @attemptLogin: (login, password, options)->
+    @attemptLogin: (login, password, options) ->
         session = new Session( login: login, password: password )
         success = options.success
-        session.save(_.extend(options,{
-            success: (reply)->
+        session.save(_.extend(options, {
+            success: (reply) ->
                 Lanes.current_user.setLoginData(session.user, session.access)
                 success.apply(options.scope, arguments)
         }))
         session
 
-class Lanes.Models.UserCollection extends Lanes.Models.Collection
-    model: Lanes.Models.User
-
 
 class Session extends Lanes.Models.Base
     api_path: 'user-session'

data/client/lanes/access/index.js

@@ -1,5 +1,4 @@
-//=require ./User
-//=require ./Roles
-//=require ./LoginDialog
-//=require ./login-dialog
-//=require ./Extension
+//= require ./User
+//= require ./Roles
+//= require ./LoginDialog
+//= require ./Extension

data/client/lanes/access/screens/user-management/Editor.cjsx

@@ -0,0 +1,20 @@
+class Lanes.Access.Screens.UserManagement.Editor extends Lanes.React.Component
+
+    mixins: [Lanes.Components.Grid.PopoverMixin]
+
+    getInitialState: ->
+        link: LC.Helpers.modelLinkFields(@props.model)
+        recordName: @props.model.name || @props.model.title
+
+    renderBody: ->
+        <form>
+            {@renderFields()}
+            <div className="field">
+                <label>Password</label>
+                <input {...@state.link('password')} type="password" />
+            </div>
+            {@renderControls()}
+        </form>
+
+    render: ->
+        @renderPopover()

data/client/lanes/access/screens/user-management/UserManagement.cjsx

@@ -0,0 +1,41 @@
+class Lanes.Access.Screens.UserManagement extends Lanes.React.Screen
+
+    getInitialState: ->
+        fields = [
+            {id:'id', visible: false}
+            'login', 'name', 'email', {id:'role_names', title:'Role Names'}
+        ]
+        query: new Lanes.Models.Query({
+            fields: fields, modelClass: Lanes.Models.User
+        })
+
+    rolesForUser: (user) ->
+        {value: user.role_names, roles: _.map(user.role_names, _.field2title)}
+
+    setRolesForUser: (model, roles) ->
+        model.role_names = _.pluck(roles, 'id')
+
+    editors: (props) ->
+        role_names: ({model}) =>
+            <LC.SelectField
+                id="role_names"
+                key="row-select"
+                editOnly multi writable unstyled
+                model={model}
+                name="roles"
+                getSelection={@rolesForUser}
+                setSelection={@setRolesForUser}
+                collection={Lanes.Models.Role.all}
+                name="role_names"
+            />
+
+    render: ->
+        <div>
+            <h1>Users Management</h1>
+            <LC.Grid
+                query={@state.query}
+                allowCreate
+                editor={Lanes.Access.Screens.UserManagement.Editor}
+                columEditors={@editors()}
+                ref="grid"/>
+        </div>

data/client/lanes/access/screens/user-management/index.js

@@ -1,3 +1,2 @@
 //= require ./UserManagement
-//= require ./GridUserEditor
 //= require_tree .

data/client/lanes/components/grid/EditingMixin.cjsx

@@ -0,0 +1,64 @@
+Lanes.Components.Grid.EditingMixin = {
+
+    propTypes:
+        topOffset: React.PropTypes.number.isRequired
+        rowIndex:  React.PropTypes.number.isRequired
+        rowHeight: React.PropTypes.number.isRequired
+        onSave:    React.PropTypes.func.isRequired
+        model:     Lanes.PropTypes.State.isRequired
+        query:     Lanes.PropTypes.State.isRequired
+        editors:   React.PropTypes.object
+        hideEditor:  React.PropTypes.func.isRequired
+
+    topOffset: ->
+        @props.topOffset + (@props.rowIndex * @props.rowHeight)
+
+    renderControls: ->
+        <div className="controls">
+            <div className="buttons">
+                <button type="button" className="btn cancel" onClick={@props.hideEditor}>
+                    <i className="icon icon-refresh" /> Cancel
+                </button>
+                <button type="button" className="btn save" onClick={@saveRecord}>
+                    <i className="icon icon-save" />Save
+                </button>
+            </div>
+        </div>
+
+    getFieldValue: (column) ->
+        @props.model[column.id]
+
+    onFieldChange: (column, ev) ->
+        @props.model[column.id] = ev.target.value
+
+    renderFields: ->
+        @props.query.fields.visible.map @renderField
+
+    renderEditingBody: ->
+        if _.isFunction(@renderBody)
+            @renderBody()
+        else
+            <div className="body">
+                <div className="fields">
+                    {@renderFields()}
+                </div>
+                {@renderControls()}
+            </div>
+
+    renderField: (column) ->
+        return null unless column.visible
+        control = if @props.editors[column.id]
+            @props.editors[column.id](model: @props.model)
+        else
+            <input type="text"
+                value={@getFieldValue(column)}
+                onChange={_.partial(@onFieldChange, column)} />
+        <div key={column.id} className="field">
+            <label>{column.title}</label>
+            {control}
+        </div>
+
+    saveRecord: ->
+        @props.model.save().then (model) =>
+            @props.onSave(model)
+}