spiderfw 0.5

data/apps/core/components/public/widgets/table.js

@@ -0,0 +1,9 @@
+Spider.defineWidget('Spider.Components.Table', {
+	
+	autoInit: true,
+	
+	ready: function(){
+		this.ajaxify($('.heading_row a, .paginator a', this.el));
+	}
+
+});

data/apps/core/components/widgets/admin/admin.rb

@@ -0,0 +1,75 @@
+require 'apps/core/auth/_init.rb'
+
+module Spider; module Components
+    
+    # This widget creates an administration page for models.
+    #
+    # Attributes:
+    # *:models*     Comma-separated list of model names
+    # *:title*
+    # *:logout_url* 
+    #
+    # Content:
+    # Takes the tags
+    # *admin:model*     A model to administer
+    # *admin:app*       Administer all models belonging to the app. Can have an 'except' attribute.
+    
+    class Admin < Spider::Widget
+        tag 'admin'
+        
+        i_attribute :models, :process => lambda{ |models| models.split(/,[\s\n]*/).map{|m| const_get_full(m) } }
+        is_attr_accessor :title, :default => _("Administration")
+        is_attr_accessor :logout_url, :default => Spider::Auth.request_url+'/login/logout'
+        
+        def init
+            @items = []
+        end
+        
+        def route_widget
+            [:switcher, @_action]
+        end
+        
+        def prepare_widgets
+            @models.each do |model|
+                crud = Crud.new(@request, @response)
+                crud.id = model.name.to_s.gsub('::', '_').downcase
+                crud.model = model
+                @widgets[:switcher].add(model.label_plural, crud, 'Gestione Dati')
+            end
+            if (@request.respond_to?(:user) && @request.user)
+                @scene.username = @request.user.to_s
+            else
+                @scene.username = _("guest")
+            end
+            super
+        end
+        
+        def run
+            @scene.current = @widgets[:switcher].current_label
+            super
+        end
+        
+        def parse_runtime_content(doc, src_path)
+            doc = super
+            mods = []
+            doc.search('admin:model').each do |mod|
+                mods << const_get_full(mod.innerText)
+            end
+            doc.search('admin:app').each do |app_tag|
+                except = []
+                if (app_tag.attributes['except'])
+                    except = app_tag.attributes['except'].split(',').map{ |e| e.strip }
+                end
+                app = const_get_full(app_tag.innerText.strip)
+                mods += app.models.select{ |m|
+                    !m.attributes[:sub_model] && m.mapper.class.write? && !except.include?(m.name.split('::')[-1])
+                }.sort{ |a, b| a.name <=> b.name }
+            end
+            @models ||= []
+            @models += mods
+            return doc
+        end
+
+    end
+    
+end; end

data/apps/core/components/widgets/admin/admin.shtml

@@ -0,0 +1,16 @@
+<div class="{ @widget[:css_class] }">
+    <tpl:asset type="css" src="css/admin.css" />
+    <div class="heading">
+	    <div class="title">
+    	    <h1>{ @title }</h1>
+	    </div>
+	    <div class="tools">
+	        Benvenuto, { @username }.
+	        <a href="{ @logout_url }">Logout</a>
+	    </div>
+    </div>
+    <div class="current_section">
+	    <span id="label">{ @current }</span>
+    </div>
+    <core:switcher id="switcher" />
+</div>

data/apps/core/components/widgets/confirm/confirm.rb

@@ -0,0 +1,37 @@
+module Spider; module Components
+    
+    class Confirm < Spider::Widget
+        tag 'confirm'
+        is_attr_accessor :actions
+        
+        def prepare
+            @scene.params = collapse_params(@request.params)
+            if (!@actions)
+                add_action('_w'+param_name(self)+'[cancel]', 'Cancel')
+                add_action('_w'+param_name(self)+'[ok]', 'Ok')
+             end
+        end
+        
+        def add_action(name, value)
+            @actions ||= []
+            @actions << [name, value]
+        end
+        
+        def collapse_params(h, first=true)
+            res = {}
+            h.each do |k, v|
+                res_key = first ? k : "[#{k}]"
+                if (v.is_a?(Hash))
+                    collapse_params(v, false).each do |v_k, v_v|
+                        res["#{res_key}#{v_k}"] = v_v
+                    end
+                else
+                    res[res_key] = v
+                end
+            end
+            return res
+        end
+        
+    end
+    
+end; end

data/apps/core/components/widgets/confirm/confirm.shtml

@@ -0,0 +1,9 @@
+<div class="">
+    <form action="{ @request[:path] }" method="POST">
+        <input sp:each="@params |name, value|" type="hidden" name="{ name }" value="{ value }" />
+        <tpl:placeholder name="text" />
+        <div class="actions">
+            <input sp:each="@actions |action|" type="submit" name="{ action[0] }" value="{ action[1] }" />
+        </div>
+    </form>
+</div>

data/apps/core/components/widgets/crud/crud.rb

@@ -0,0 +1,119 @@
+
+
+module Spider; module Components
+    
+    class Crud < Spider::Widget
+        tag 'crud'
+        is_attr_accessor :model, :required => true
+        is_attribute :action, :type => Symbol, :default => :table
+        attribute :table_elements
+        attr_accessor :fixed
+
+        def route_widget
+            [@action, @_action]
+        end
+        
+        def prepare(action='')
+            @action = (@_action_local && !@_action_local.empty?) ? :form : :table
+            @_pass_action = (@action == :form) ? @_action : nil
+            @scene.saved = flash[:saved]
+            if (params['delete_cancel'])
+                params.delete('delete')
+                params.delete('do_delete')
+            end
+            if (params['delete'] && !params['do_delete'] && params['selected'])
+                @scene.ask_delete = true
+            end
+            super
+            transient_session[:table_params] = @widgets[:table].params if (@widgets[:table])
+            
+            if (@action == :table)
+                if params['do_delete'] && params['selected'] && params['selected'].length > 0
+                    delete_rows
+                    flash[:deleted] = true
+                    return redirect(widget_request_path)
+                elsif params['delete'] && params['selected']
+                    @scene.ask_delete = true
+                    rows = []
+                    descs = @model.find({ @model.primary_keys[0].name => params['selected'].keys[0..9]})
+                    descs.each { |obj| rows << obj.to_s }
+                    total = params['selected'].keys.length
+                    rows << "Altri #{total - 10}" if total > 10
+                    @widgets[:ask_delete].scene.rows_to_del = rows
+                end
+            elsif (@action == :form)
+           #     debugger
+                if (@widgets[:form].saved?)
+                    flash[:saved] = true
+                    if (@widgets[:form].saved_and_new?)
+                        redirect(widget_request_path+'/new')
+                    elsif (@widgets[:form].saved_and_stay?)
+                        redirect(widget_request_path+'/'+@widgets[:form].pk)
+                    else
+                        redirect(widget_request_path)
+                    end
+                end
+            end
+            
+        end
+        
+        def prepare_widgets
+            if (@action == :table && @widgets[:table])
+                @key_element = @model.primary_keys[0].name
+                table_page = nil
+                if (transient_session[:table_params])
+                    table_page = transient_session[:table_params]['page'] if transient_session[:table_params]['page']
+                end
+                table_page = 1 if params['table_q'] || params['clear_table_q']
+                @widgets[:table].page = table_page
+                @widgets[:table].attributes[:elements] = @attributes[:table_elements]
+                @widgets[:table].scene.key_element = @key_element
+                @widgets[:table].scene.crud_path = @full_path
+                @widgets[:table].scene.crud = widget_to_scene(self)
+                @table_q = params['table_q']
+                @table_q ||= transient_session[:table_q]
+                @table_q = nil if params['clear_table_q']
+                if (@table_q)
+                    @widgets[:table].add_condition(@model.free_query_condition(@table_q))
+                end
+                transient_session[:table_q] = @table_q
+                if(@condition && @widgets[:table])
+                    @widgets[:table].add_condition(@condition)
+                end
+                @scene.table_q = @table_q
+            end
+            if (@fixed)
+                if (@widgets[:table])
+                    c = Spider::Model::Condition.new(@fixed)
+                    @widgets[:table].add_condition(c)
+                elsif (@widgets[:form])
+                    @widgets[:form].fixed = @fixed
+                end
+            end
+            if (@widgets[:ask_delete])
+                @widgets[:ask_delete].add_action('_w'+param_name(self)+'[delete_cancel]', _("Cancel"))
+                @widgets[:ask_delete].add_action('_w'+param_name(self)+'[do_delete]', _('Ok'))
+            end
+            
+            super
+            
+        end
+        
+        def after_widget(id)
+            if (id == :table)
+                links = {}
+                table_rows = @widgets[:table].scene.data
+                table_rows.each_index do |i|
+                    links[i] = "#{widget_request_path}/#{table_rows[i][@key_element]}"
+                end
+                @widgets[:table].scene.links_to_form = links
+            end
+        end
+        
+        def delete_rows
+            @model.mapper.delete({ @model.primary_keys[0].name => params['selected'].keys})
+        end
+        
+    end
+    
+end; end

data/apps/core/components/widgets/crud/crud.shtml

@@ -0,0 +1,59 @@
+<div class="{ @widget[:css_class] }">
+    <tpl:asset type="css" src="css/crud.css" />
+    <div sp:if="@saved" class="flash">
+        Salvataggio effettuato
+    </div>
+    <div sp:if="@deleted" class="flash">
+        Cancellazione effettuata
+    </div>
+    <div sp:if="@action == :form" class="top">
+        <a class="back" href="{ @widget[:request_path] }">
+            Torna all'elenco { @model.label_plural.downcase }
+        </a>
+    </div>
+    <core:confirm id="ask_delete" sp:if="@ask_delete">
+        <tpl:content name="text">
+            Sei sicuro di voler cancellare i seguenti elementi?
+            <ul>
+                <li sp:each="@rows_to_del |row|">
+                    { row }
+                </li>
+            </ul>
+        </tpl:content>
+    </core:confirm>
+    <sp:pass sp:if="!@ask_delete">
+        <div sp:if="@action == :table" class="top">
+            <a class="add" href="{ @widget[:request_path] }/new">
+                Crea nuovo
+            </a>
+        </div>
+        <div class="table_search" sp:if="@action == :table">
+            <form action="{ @request[:path] }" method="GET">
+                <input type="text" name="_w{ param_name(@widget) }[table_q]" value="{ @table_q }">
+                <input type="submit" name="submit" value="Trova">
+                <input type="submit" name="_w{ param_name(@widget) }[clear_table_q]" value="Pulisci">
+            </form>
+        </div>
+        <core:table sp:if="@action == :table" id="table" model="@model">
+            <tpl:override-content search="table .row td">
+                <a href="{ @links_to_form[row_i] }" sp:tag-if="element == @key_element"><tpl:overridden /></a>
+            </tpl:override-content>
+            <tpl:append search="table .heading_row">
+                <th>Sel.</th>
+            </tpl:append>
+            <tpl:override search="table">
+                <form sp:if="@rows && @rows.length > 0" action="{ @request[:path] }" method="POST">
+                    <tpl:overridden />
+                    <div class="crud_table_actions">
+                        <input type='submit' name="_w{ param_name(@crud) }[delete]" value="Cancella selezionati">
+                    </div>
+                </form>
+            </tpl:override>
+            <tpl:append search="table .row">
+                <td align="center"><input type='checkbox' name="_w{ param_name(@crud) }[selected][{ @data[row_i][@key_element] }]"></td>
+            </tpl:append>
+            <tpl:override-attr search="table .paginator td" name="colspan" value="{ elements.size + 1 }" />
+        </core:table>
+        <forms:form sp:if="@action == :form" id="form" model="@model" show_related="true" show_additional_buttons="true" />
+    </sp:pass>
+</div>

data/apps/core/components/widgets/crud/form_table/form_table.rb

@@ -0,0 +1,13 @@
+module Spider; module Components
+    
+    class FormTable < Spider::Widget
+        attr_accessor :owner, :owner_element
+        
+        def start
+            @list = @owner[@owner_element]
+            @widgets[:table].queryset = @list
+        end
+ 
+    end
+    
+end; end

data/apps/core/components/widgets/crud/form_table/form_table.shtml

@@ -0,0 +1,3 @@
+<div class="form_table">
+    <sp:table id="table" />
+</div>

data/apps/core/components/widgets/list/list.rb

@@ -0,0 +1,294 @@
+module Spider; module Components
+
+    class List < Spider::Widget
+        tag 'list'
+
+        i_attribute :lines, :required => :datasource
+        i_attr_accessor :queryset, :required => :datasource
+        i_attr_accessor :model, :required => :datasource
+        i_attribute :keys
+        is_attribute :delete, :default => false, :process => lambda{ |v| return true if v == "true"; return false if v == "false"; v }
+        is_attribute :delete_param
+        is_attribute :delete_mode, :default => 'all'
+        is_attribute :sortable; is_attribute :collapsable; is_attribute :collapsed
+        is_attribute :tree
+        is_attr_accessor :actions
+        is_attribute :sub_elements
+        is_attribute :is_child
+        is_attribute :paginate, :type => Fixnum, :default => false
+        is_attribute :searchable, :type => Spider::DataTypes::Bool
+        # Display message if list is empty
+        attribute :show_empty, :type => Spider::DataTypes::Bool
+        # Display empty <ul></ul> (default: false)
+        is_attribute :show_empty_list, :type => Spider::DataTypes::Bool
+        i_attribute :dereference_junction
+        i_attribute :dereference_sort, :type => Spider::DataTypes::Bool, :default => false
+        i_attribute :dereference_delete, :type => Spider::DataTypes::Bool, :default => true
+        is_attribute :list_tag, :default => 'ul'
+        i_attribute :element
+        i_attribute :parent_obj
+
+        def widget_init(action='')
+            super
+            @sortable = @sortable.to_sym if @sortable
+            @tree = @tree.to_sym if @tree
+            @model = const_get_full(@model) if @model.is_a?(String)
+            if (@model && !@queryset)
+                @queryset = @tree ? @model.roots : @model.all 
+            elsif @queryset
+                @model = @queryset.model
+            end
+        end
+
+
+        def prepare
+            @scene.start_list_tag = "<#{@list_tag}>"
+            @scene.close_list_tag = "</#{@list_tag}>"
+            @sublists = []
+            if (@sub_elements && @sub_elements.is_a?(String))
+                @sub_elements = @sub_elements.split(/,\s+/).map{ |el| el.to_sym }
+            end
+            @sub_elements ||= []
+            @requested_sublists ||= []
+            if (@attributes[:paginate])
+                @page = params['page'] if params['page']
+                @page ||= 1
+                @page = @page.to_i
+                @offset = ((@page - 1) * @attributes[:paginate])
+                @scene.page = @page
+            end
+            @keys = []
+            @delete_keys = []
+            @values = []
+            if (params['delete'])
+                delete(params['delete'])
+            end
+            @dereference_junction = @dereference_junction.to_sym if @dereference_junction
+            css_model = @dereference_junction ? @model.elements[@dereference_junction].model : @model
+            @scene.model_class = css_model_class(css_model)
+            
+            @css_classes << 'sortable' if @sortable
+            @css_classes << 'collapsable' if @collapsable
+            @css_classes << 'collapsed' if @collapsed
+            @css_classes << 'sublist' if @attributes[:is_child]
+            @css_classes << 'tree' if @attributes[:tree]
+            @scene.show_empty = @attributes[:show_empty]
+            if (!@lines && @queryset)
+                if (@attributes[:paginate])
+                    @queryset.offset = @offset
+                    @queryset.limit = @attributes[:paginate]
+                end
+                @scene.search_submit_text = _("Go")
+                @scene.search_clear_text = _("Clear")
+                @search_query = params['q'] || session['q']
+                @search_query = nil if params['clear']
+                session['q'] = @search_query
+                if (@attributes[:searchable] && @search_query)
+                    @scene.search_query = @search_query.to_s
+                    @queryset.condition.and(@queryset.model.free_query_condition(@search_query))
+                end
+            end
+            if (@widget_target)
+                first, rest = @widget_target.split('/', 2)
+                if first =~ /sublist_(\d+)_(.+)/
+                    cnt = $1.to_i
+                    sublist_id = $2
+                    found = @requested_sublists.select{ |sbl| sbl['id'] == sublist_id }[0]
+                    row = @queryset[cnt]
+                    if (@dereference_junction)
+                        row = row.get(@dereference_junction)
+                    end
+                    create_requested_sublist(found, row, cnt) if (found)
+                end
+            end
+            super
+        end
+        
+        def run
+            if (!@lines && @queryset)
+                @lines = []
+                cnt = 0
+                @queryset.each do |row|
+                    if (@dereference_junction)
+                        dr_keys = keys_string(row)
+                        row = row.get(@dereference_junction)
+                    end
+                    @keys << keys_string(row)
+                    if (@dereference_junction && !@dereference_sort)
+                        @sort_keys ||= []
+                        @sort_keys << dr_keys
+                    end
+                    @delete_keys << ((@dereference_junction && !@dereference_delete) ? dr_keys : @keys.last)
+                    cnt2 = 0
+                    if @tree && row.get(@tree).length > 0
+                        sl = create_sublist("sublist_#{cnt}_#{cnt2+=1}")
+                        if (@dereference_junction && @model.elements[@tree].model == @model.elements[@dereference_junction].model)
+                            sl.attributes[:dereference_junction] = nil
+                        end
+                        sl.queryset = row.get(@tree)
+                        @sublists[cnt] ||= []
+                        @sublists[cnt] << sl
+                        sl.run
+                    end
+                    @sub_elements.each do |el|
+                        sub = row.get(el)
+                        sl = create_sublist("sublist_#{cnt}_#{el}")
+                        sl.queryset = sub
+                        @sublists[cnt] ||= []
+                        @sublists[cnt] << sl
+                        sl.run
+                    end
+                    @requested_sublists.each do |sbl|
+                        sl = create_requested_sublist(sbl, row, cnt)
+                        sl.run
+                    end
+                    @values << row
+                    @lines << format_line(row)
+                    cnt += 1
+                end
+                if (@attributes[:paginate])
+                    @scene.has_more = @queryset.has_more?
+                    @scene.pages = (@queryset.total_rows.to_f / @attributes[:paginate]).ceil
+                end
+            end
+            @lines ||= []
+            @scene.lines = @lines
+            @scene.keys = @keys
+            @scene.values = @values
+            @scene.sublists = @sublists
+            @scene.delete_keys = @delete_keys
+            @scene.sort_keys = @sort_keys
+            @attributes[:delete] = @request.path if @attributes[:delete] == true
+            if (@attributes[:delete])
+                @scene.delete_link = @attributes[:delete]
+                if (@delete_param)
+                    @scene.delete_link += "?#{@delete_param}"
+                else
+                    @scene.delete_link += "?_w#{param_name(self)}[delete]="
+                end
+            end
+        end
+        
+        def create_requested_sublist(sbl, row, cnt)
+            attributes = sbl.attributes.clone
+            if (attributes['element'])
+                el = @model.elements[attributes['element'].to_sym]
+                #next unless el # may be ok if the query is polymorphic
+                # if (sl['tree'] && el && el.attributes[:reverse])
+                #     sub = el.model.send("#{sl['tree']}_roots")
+                #     sub.condition[el.attributes[:reverse]] = row
+                # else
+                sub = row.get(attributes['element'].to_sym)
+#                end
+            end
+            el_name = attributes['element']
+            attributes.delete('element')
+            sl = create_sublist("sublist_#{cnt}_#{attributes['id']}", attributes)
+            if (el && el.model != @model)
+                sl.attributes[:model] = el.model
+                sl.attributes[:dereference_junction] = nil unless attributes['dereference_junction']
+            end
+            if (el)
+                sl.attributes[:element] = el
+                sl.attributes[:parent_obj] = row
+            end
+            sl.parse_runtime_content_xml("<sp:widget-content>#{sbl.innerHTML}</sp:widget-content>")
+            sl.queryset = sub
+            sl.css_classes << "sublist_#{el_name}"
+            @sublists[cnt] ||= []
+            @sublists[cnt] << sl
+            return sl
+        end
+
+        def create_sublist(name, attributes = {})
+            w = create_widget(self.class, name, @request, @response)
+            if (attributes['inherit_template'] && @template)
+                w.template = @template
+            end
+            w.attributes[:tree] = @tree
+            w.attributes[:actions] = @actions
+            w.attributes[:is_child] = true
+            @attributes.each do |key, val|
+                w.attributes[key.to_sym] = val
+            end
+            attributes.each do |key, val|
+                w.attributes[key.to_sym] = val if w.class.attribute?(key)
+            end
+            w.widget_before
+            return w
+        end
+
+        def keys_string(obj)
+            obj.keys_string
+        end
+
+        def format_line(obj)
+            obj.to_s
+        end
+
+        def parse_runtime_content(doc, src_path='')
+            doc = super
+            return doc if doc.children.empty?
+            doc.root.xpath('sublist', Template.xml_namespaces).each do |sl|
+                raise ArgumentError, "Sublist of #{@id} does not have an id" unless sl['id']
+                @requested_sublists ||= []
+                @requested_sublists << sl
+            end
+            return doc.root
+        end
+
+        __.json
+        def sort(id, pos)
+            raise "List #{@id} is not sortable" unless @sortable
+            obj = @model.new(id)
+            obj.set(@sortable, pos)
+            obj.save
+            $out << "{res: 'ok'}"
+        end
+        
+        __.json
+        def tree_sort(id, parent_id, prev_id=nil)
+            #debugger
+            raise "List #{@id} is not a tree" unless @tree
+            raise "List #{@id} is not sortable" unless @sortable
+            obj = @model.new(id)
+            parent = @model.new(parent_id) if parent_id && !parent_id.empty?
+            prev = @model.new(prev_id) if prev_id && !prev_id.empty?
+            unless parent || prev
+                if (@parent_obj.class == @model)
+                    parent = @parent_obj
+                else
+                    raise "No parent or prev given" 
+                end
+            end
+            tree_el = @model.elements[@tree]
+            obj_parent = obj.get(tree_el.attributes[:reverse])
+#            if (obj_parent)
+             @model.mapper.tree_remove(tree_el, obj)
+#            end
+            if (prev)
+                @model.mapper.tree_insert_node_right(tree_el, obj, prev)
+            else
+                @model.mapper.tree_insert_node_first(tree_el, obj, parent)
+            end
+            obj.save
+            $out << "{res: 'ok'}"
+        end
+        
+        def delete(id)
+            if (@delete_mode == 'all')
+                obj = @model.new(id)
+                if (@tree)
+                    obj.mapper.tree_delete(@model.elements[@tree], obj)
+                else
+                    obj.delete
+                end
+            else
+                
+            end
+        end
+
+
+    end
+
+end; end