X-Git-Url: http://git.osdn.net/view?p=pettanr%2Fpettanr.git;a=blobdiff_plain;f=app%2Fassets%2Fjavascripts%2Flocmare%2Fform.js.coffee;h=4e55865ab24a942d55146c54ea6c7e2d2bf80b47;hp=bd2c9e597ff8ce000b1819fe71d7e4276bd1607b;hb=aa9eca25671c772ffec8f2f65aecc8a978a2f375;hpb=cd04b33f21158d7885439b1f2ad6ab8783aed98f

diff --git a/app/assets/javascripts/locmare/form.js.coffee b/app/assets/javascripts/locmare/form.js.coffee
index bd2c9e59..4e55865a 100644
--- a/app/assets/javascripts/locmare/form.js.coffee
+++ b/app/assets/javascripts/locmare/form.js.coffee
@@ -1,17 +1,15 @@
 # form_name_with_sub_form
 # item: editing item
-# mounted: true/false
 # submit: string / 'submit'
-# operators: 
 class Locmare.FormBase extends Backbone.View
   tagName: 'form'
   
   initialize: (options) ->
     @form_name = options.form_name #_with_sub_form
+    @use_name = options.use_name || 'default'
     @item = options.item
-    @mounted = options.mounted
+    @element_form = options.element_form
     @submit = options.submit
-    @operators = options.operators
     if /\./.test(@form_name)
       @sub_form_names = @form_name.split('.')
       @form_name = @sub_form_names.pop()
@@ -20,8 +18,12 @@ class Locmare.FormBase extends Backbone.View
       @sub_form_names = []
       #@form_name = @form_name
       @root_form_name = @form_name
-    @manifest = LocalManifest.manifest().forms[@form_name]
+    @manifest = LocalManifest.manifest().forms[@form_name].uses[@use_name]
     @fields = {}
+    @on('change:field', @change)
+  
+  change: (field) ->
+    console.log(field.field_name)
   
   fold_extend_settings: (params) ->
     @item.my_class().fold_extend_settings params[@item.item_name()]
@@ -37,62 +39,121 @@ class Locmare.FormBase extends Backbone.View
   image_dir: () ->
     '/images/'
   
+  quit: () ->
+    null
+  
 class Locmare.Form extends Locmare.FormBase
   
+  @factory: (options) ->
+    custom_form = Pettanr.Views[Pettanr.camelize(options.item.model_name())].Form
+    if custom_form
+      new custom_form(options)
+    else
+      new Locmare.Form(options)
+  
   initialize: (options) ->
     super(options)
     @submit = options.submit
-    @action = options.action
+    @child_forms = {}
     @item.boosts 'post'
     @init_fields()
   
   render: () ->
-    method_type = if @item.isNew()
-      'post'
-    else
-      'put'
-    @attr = {
-      method: method_type,
-      action: @action
-    }
-    this.$el.attr(@attr)
+    this.$el.attr(@form_attr())
     this.$el.html('')
     @error_explanation = null
     @div_fields = new Locmare.FormModule.Fields({
-      fields: @fields
+      parent: this, fields: @fields
     })
     #this.$el.append(@error_explanation.render().el) if not @error_explanation
     this.$el.append(@div_fields.render().el)
+    @add_elements() if @element_form
     if @submit
       c = @submit_class()
       @div_submit = new c({form: this})
       this.$el.append(@div_submit.render().el)
-      @delegateEvents({'submit': method_type})
+      @delegateEvents({'submit': @method_type()})
     this
   
+  form_attr: () ->
+    {
+      method: @method_type(),
+      action: @action_url()
+    }
+  
+  refresh: () ->
+    _.each @fields, (field) =>
+      field.refresh()
+    _.each @child_forms, (child_form, name) =>
+      child_form.refresh()
+  
+  method_type: () ->
+    if @item.isNew()
+      'post'
+    else
+      'put'
+  
+  action_url: () ->
+    return null if !@submit    # element has not create actions
+    if @item.isNew()
+      @item.create_url()
+    else
+      @item.edit_url()
+  
+  add_elements: () ->
+    _.each @item.my_class().child_models(), (element_model) =>
+      items = @item.element_items(element_model)
+      if @item.my_class().my_manifest().associations.is_has_one(element_model)
+        @add_element(items)
+      else
+        _.each items, (item) =>
+          @add_element(item)
+  
+  add_element: (element) ->
+    form = Locmare.Form.factory({
+      form_name: element.item_name(), 
+      use_name: @use_name,
+      item: element, 
+      element_form: @element_form, 
+      submit: null, 
+    })
+    this.$el.append(form.render().el)
+    mm = @item.my_class().my_manifest()
+    em = element.my_class().my_manifest()
+    child_element_name = mm.associations.child_element_name(element.my_class())
+    if mm.associations.is_has_one(em)
+      @child_forms[child_element_name] = form
+    else
+      @child_forms[child_element_name] ||= []
+      @child_forms[child_element_name].push(form)
+    form
+  
+  remove_elements: () ->
+    _.each @child_forms, (child_form, name) =>
+      child_form.item.set({_destroy: true}, {silent: true})
+      child_form.remove_elements()
+  
   init_fields: () ->
-    _this = this
-    _.each _this.manifest.field_names, (field_name) ->
-      field_manifest = _this.manifest.fields[field_name]
-      boost_name = _this.item.my_class().find_boost_name(field_name)
+    _.each @manifest.field_names, (field_name) =>
+      field_manifest = @manifest.fields[field_name]
+      boost_name = @item.my_class().find_boost_name(field_name)
       extend_model = if boost_name 
-        _this.item.boosters[boost_name].extend_model()
+        @item.boosters[boost_name].extend_model()
       else
         null
       if boost_name and extend_model # field is extend setting AND template has a extend model
-        extend_form_name = _this.item.boosters[boost_name].item_name()
-        extend_item = _this.item.boosters[boost_name].extend_item()
-        _this.fields[field_name] = new Locmare.ExtendForm({
-          parent: _this, 
+        extend_form_name = @item.boosters[boost_name].item_name()
+        extend_item = @item.boosters[boost_name].extend_item()
+        @fields[field_name] = new Locmare.ExtendForm({
+          parent: this, 
           form_name: extend_form_name, 
+          use_name: @use_name,
           item: extend_item, 
-          mounted: _this.mounted, 
-          operators: _this.operators, 
           field_name: field_name
         })
       else
-        _this.fields[field_name] = new Locmare.FormModule.Field({
-          form: _this, 
+        @fields[field_name] = new Locmare.FormModule.Field({
+          form: this, 
           field_name: field_name, 
           field_manifest: field_manifest
         })
@@ -106,25 +167,64 @@ class Locmare.Form extends Locmare.FormBase
     @submits()[@submit]
   
   post: () ->
-    _this = this
-    _.each @fields, (field) ->
-      _this.item.set(field.field_name, field.val())
-    if @item.save()
-      window.router.navigate('/' + @item.table_name() + '/' + Pettanr.to_s(@item.get('id')), true)
-      return false
-    else
-      alert('invalid')
+    _.each @fields, (field) =>
+      field.fold() if field.is_extend()
+      @item.set(field.field_name, field.val())
+    @item.unset('id')  # isNew use flag that id attr set
+    @trigger('http_post', @item.create_url(), this)
+    return false
   
   put: () ->
-    _this = this
-    _.each @fields, (field) ->
-      _this.item.set(field.field_name, field.val())
-    @item.overwrite({operators: @operators})
-    if @item.save()
-      window.router.navigate('/' + @item.table_name() + '/' + Pettanr.to_s(@item.get('id')), true)
-      return false
+    _.each @fields, (field) =>
+      field.fold() if field.is_extend()
+      @item.set(field.field_name, field.val())
+    @trigger('http_post', @item.update_url(), this)
+    return false
+  
+  save: () ->
+    @listenTo(@item, 'save:success', @success)
+    @listenTo(@item, 'save:fail', @fail)
+    @item.save()
+  
+  success: (model, response) ->
+    if !Pettanr.cache.restore(model.cache_key())
+      # item is new
+      model.url = model.default_url()
+      Pettanr.cache.store(model)
     else
-      alert('invalid')
+      @item.fix()
+    @trigger('success', model, response)
+  
+  fail: (model, response) ->
+    @trigger('fail', response)
+  
+  quit: () ->
+    @item.release()
+  
+  save_data: (inspire = false) ->
+    @item.my_class().child_models()
+    attrs = {}
+    _.each @fields, (field) =>
+      attrs[field.field_name] = @item.get(field.field_name)
+    delete attrs['id'] if @item.isNew()
+    _.each @child_forms, (child_form, name) =>
+      mm = @item.my_class().my_manifest()
+      em = child_form.item.my_class().my_manifest()
+      if mm.associations.is_has_one(em)
+        d = child_form.save_data(inspire)
+        if inspire
+          delete d['id']
+          delete d[@item.item_name() + '_id']
+        attrs[name + '_attributes'] = d
+      else
+        attrs[name + '_attributes'] = []
+        _.each child_form, (form) =>
+          d = form.save_data(inspire)
+          if inspire
+            delete d['id']
+            delete d[@item.item_name() + '_id']
+          attrs[name + '_attributes'].push(d)
+    attrs
   
 class Locmare.ExtendForm extends Locmare.FormBase
   tagName: 'div'
@@ -134,6 +234,7 @@ class Locmare.ExtendForm extends Locmare.FormBase
     @parent = options.parent
     @field_name = options.field_name
     super(options)
+    @listenTo(@item, 'input', @input)
     @field = new Locmare.FormModule.Field({
       form: @parent, 
       field_name: @field_name, 
@@ -144,18 +245,40 @@ class Locmare.ExtendForm extends Locmare.FormBase
   
   render: () ->
     this.$el.html('')
-    @div_fields = new Locmare.FormModule.Fields({
-      fields: @fields
-    })
-    this.$el.append(@div_fields.render().el)
+    if !@is_hidden()
+      this.$el.append(@label.render().el) if not @label.hidden()
+      @div_fields = new Locmare.FormModule.Fields({
+        fields: @fields
+      })
+      this.$el.append(@div_fields.render().el)
     this
   
+  refresh: () ->
+    @field.refresh()
+  
+  input: (field) ->
+    a = {}
+    a[@field_name] = @val()
+    @parent.item.set(a, {silent: true})
+    @parent.item.trigger('input:' + @field_name + ':' + field)
+    @parent.item.trigger('input:' + @field_name)
+    @parent.item.trigger('input')
+  
+  fold: () ->
+    _.each @fields, (field) =>
+      @item.set(field.field_name, field.val())
+  
+  val: () ->
+    JSON.stringify(@item.attributes)
+  
+  is_hidden: () ->
+    _.isEmpty(@manifest.field_names)
+  
   init_fields: () ->
-    _this = this
-    _.each _this.manifest.field_names, (field_name) ->
-      field_manifest = _this.manifest.fields[field_name]
-      _this.fields[field_name] = new Locmare.FormModule.ExtendField({
-        form: _this, 
+    _.each @manifest.field_names, (field_name) =>
+      field_manifest = @manifest.fields[field_name]
+      @fields[field_name] = new Locmare.FormModule.ExtendField({
+        form: this, 
         field_name: field_name, 
         field_manifest: field_manifest
       })
@@ -164,20 +287,23 @@ class Locmare.ExtendForm extends Locmare.FormBase
     # parent is field
     @parent.form_field_name(@field_name)  + '[' + extend_field_name + ']'
   
+  is_extend: () ->
+    true
+  
 class Locmare.FormModule
 class Locmare.FormModule.Fields extends Backbone.View
   tagName: 'div'
   className: 'fields'
   
   initialize: (options) ->
+    @parent = options.parent
     @fields = options.fields
   
   render: () ->
     this.$el.html('')
-    _this = this
-    _.each @fields, (field) ->
-      _this.$el.append(field.render().el)
-      _this.$el.append(field.rb.render().el) if field.rb
+    _.each @fields, (field) =>
+      this.$el.append(field.render().el)
+      this.$el.append(field.rb.render().el) if field.rb
     this
   
 class Locmare.FormModule.SubmitModule