app/controllers/application_controller.rb

   1 class ApplicationController < ActionController::Base
   2   protect_from_forgery
   3   layout :devise_layout
   4   before_filter :bf
   5
   6   def devise_layout
   7     if devise_controller?
   8       case resource_name
   9       when :admin
  10         'guest'
  11       when :user
  12         'guest'
  13       when :demand_user
  14         'guest'
  15       end
  16     else
  17       'application'
  18     end
  19   end
  20
  21   def bf
  22     @server_result = {
  23       :location => {:controller => params[:controller], :action => params[:action]}
  24     }
  25     @server_result[:location][:id] = params[:id] if params[:id]
  26     user = if user_signed_in?
  27       current_user
  28     else
  29       nil
  30     end
  31     author = if user
  32       user.author
  33     else
  34       nil
  35     end
  36     artist = if user
  37       user.artist
  38     else
  39       nil
  40     end
  41     admin = if admin_signed_in?
  42       current_admin
  43     else
  44       nil
  45     end
  46     demand_user = if demand_user_signed_in?
  47       current_demand_user
  48     else
  49       nil
  50     end
  51     @operators = Operator.new [user, author, artist, admin, demand_user]
  52   end
  53
  54   def authenticate_reader
  55     authenticate_user! unless @operators.reader?
  56   end
  57
  58   def authenticate_user
  59     authenticate_user! unless @operators.user?
  60   end
  61
  62   def authenticate_resource_reader
  63     authenticate_user! unless @operators.resource_reader?
  64   end
  65
  66   def authenticate_admin
  67     authenticate_admin! unless @operators.admin?
  68   end
  69
  70   def authenticate_author
  71     if @operators.author
  72       true
  73     else
  74       respond_to do |format|
  75         format.html { redirect_to main_app.new_author_path, :status => :found }
  76         format.json {
  77           raise ActiveRecord::Forbidden
  78         }
  79       end
  80       false
  81     end
  82   end
  83
  84   def authenticate_artist
  85     if @operators.artist
  86       true
  87     else
  88       respond_to do |format|
  89         format.html { redirect_to main_app.new_artist_path, :status => :found }
  90         format.json {
  91           raise ActiveRecord::Forbidden
  92         }
  93       end
  94       false
  95     end
  96   end
  97
  98   def self.controller
  99     Manifest.manifest.controllers[self.model.item_name]
 100   end
 101
 102   def self.profiler_manager
 103     Manifest.manifest.profiler_managers[self.model.item_name]
 104   end
 105
 106   def set_model
 107     @my_controller = Manifest.manifest.controllers[params[:controller].to_s]
 108     @my_action = @my_controller.actions[params[:action].to_s]
 109     @my_model = Manifest.manifest.models[@my_controller.item_name]
 110     @my_model_class = @my_model.classify
 111   end
 112
 113   def set_list
 114     set_model
 115     @my_list_model = Manifest.manifest.models[@my_action.item_name]
 116     @my_list_model_class = @my_list_model.classify
 117     @list = Locmare::ListGroup.list @my_action.item_name, @my_action.list_name
 118   end
 119
 120   def filer_list
 121     set_list
 122     list_result = @list.open(@operators,
 123       {:id => params[:id], :page => params[:page], :page_size => params[:page_size]}
 124     )
 125     @items = list_result.items
 126     respond_to do |format|
 127       format.html {
 128         @filer = Locmare::Filer.new @list.item_name, list_result.items, list_result, :default, @operators
 129         render @filer.template_name, :locals => {
 130           :filer => @filer
 131         }
 132       }
 133       format.json { render json: @items.to_json }
 134       format.atom
 135       format.rss
 136     end
 137   end
 138
 139   def set_play
 140     set_list
 141     @item = @my_model_class.show(params[:id], @operators)
 142   end
 143
 144   def play_list
 145     @options = {:id => params[:id], :my_play => @item.own?(@operators),
 146       :offset => params[:offset], :count => params[:count],
 147       :page => params[:page], :page_size => params[:page_size]
 148     }
 149     list_result = @list.open(@operators, @options)
 150     @items = list_result.items
 151     @count = list_result.count
 152     @pager = list_result.paginate
 153   end
 154
 155   def set_show
 156     set_model
 157     @item = @my_model_class.show(params[:id], @operators)
 158   end
 159
 160   def show_prof_format format
 161     format.prof {
 162       self.formats = [:html]
 163       @profiler = Locmare::Profiler.new @my_model.model_name, @item, @operators
 164       render @profiler.template_name, :locals => {
 165         :profiler => @profiler
 166       }
 167     }
 168   end
 169
 170   def show_json_format format
 171     format.json { render json: @item.to_json(@my_model_class.show_json_opt) }
 172   end
 173
 174   def show_json_format_for_root format
 175     format.json { render json: @item.to_json(@my_model_class.show_json_opt_for_root) }
 176   end
 177
 178   def set_new
 179     set_model
 180     @item = @my_model_class.new
 181     @item.boosts 'post'
 182     @item.supply_default
 183   end
 184
 185   def set_edit
 186     set_model
 187     @item = @my_model_class.edit(params[:id], @operators)
 188     @item.boosts 'post'
 189   end
 190
 191   def render_form
 192     respond_to do |format|
 193       format.html {
 194         @form = Locmare::Bucket.factory @item.item_name, @item, true, true, @operators
 195         render @form.template_name, :locals => {
 196           :form => @form
 197         }
 198       }
 199       format.json { render json: @item.to_json }
 200     end
 201   end
 202
 203   def form_new
 204     set_new
 205     render_form
 206   end
 207
 208   def form_edit
 209     set_edit
 210     render_form
 211   end
 212
 213   def created_html_format format, redirect_url = nil
 214     format.html {
 215       flash[:notice] = I18n.t('flash.notice.created', :model => @my_model_class.model_name.human)
 216       redirect_to (redirect_url ? redirect_url : @item)
 217     }
 218   end
 219
 220   def created_json_format format
 221     format.json {
 222       render json: @item.to_json(@my_model_class.show_json_opt), status: :created, location: @item
 223     }
 224   end
 225
 226   def not_created_html_format format
 227     format.html {
 228       flash[:notice] = I18n.t('flash.notice.not_created', :model => @my_model_class.model_name.human)
 229       render_form
 230     }
 231   end
 232
 233   def not_created_json_format format
 234     format.json {
 235       render json: @item.errors, status: :unprocessable_entity
 236     }
 237   end
 238
 239   def render_create redirect_url = nil
 240     if @item.save
 241       respond_to do |format|
 242         created_html_format format, redirect_url
 243         created_json_format format
 244       end
 245     else
 246       respond_to do |format|
 247         not_created_html_format format
 248         not_created_json_format format
 249       end
 250     end
 251   end
 252
 253   def leaf_created_html_format format, redirect_url
 254     format.html {
 255       flash[:notice] = I18n.t('flash.notice.created', :model => @my_model_class.model_name.human)
 256       redirect_to redirect_url
 257     }
 258   end
 259
 260   def leaf_not_created_html_format format, redirect_url
 261     format.html {
 262       flash[:notice] = I18n.t('flash.notice.not_created', :model => @my_model_class.model_name.human)
 263       redirect_to redirect_url
 264     }
 265   end
 266
 267   def leaf_render_create redirect_url
 268     if @item.store @operators
 269       respond_to do |format|
 270         leaf_created_html_format format, redirect_url
 271         created_json_format format
 272       end
 273     else
 274       respond_to do |format|
 275         leaf_not_created_html_format format, redirect_url
 276         not_created_json_format format
 277       end
 278     end
 279   end
 280
 281   def updated_html_format format, redirect_url = nil
 282     format.html {
 283       flash[:notice] = I18n.t('flash.notice.updated', :model => @my_model_class.model_name.human)
 284       redirect_to (redirect_url ? redirect_url : @item)
 285     }
 286   end
 287
 288   def updated_json_format format
 289     format.json {
 290       head :ok
 291     }
 292   end
 293
 294   def not_updated_html_format format
 295     format.html {
 296       flash[:notice] = I18n.t('flash.notice.not_updated', :model => @my_model_class.model_name.human)
 297       render_form
 298     }
 299   end
 300
 301   def not_updated_json_format format
 302     format.json {
 303       render json: @item.errors, status: :unprocessable_entity
 304     }
 305   end
 306
 307   def render_update redirect_url = nil
 308     if @item.save
 309       respond_to do |format|
 310         updated_html_format format, redirect_url
 311         updated_json_format format
 312       end
 313     else
 314       respond_to do |format|
 315         not_updated_html_format format
 316         not_updated_json_format format
 317       end
 318     end
 319   end
 320
 321   def leaf_updated_html_format format, redirect_url
 322     format.html {
 323       flash[:notice] = I18n.t('flash.notice.updated', :model => @my_model_class.model_name.human)
 324       redirect_to redirect_url
 325     }
 326   end
 327
 328   def leaf_not_updated_html_format format, redirect_url
 329     format.html {
 330       flash[:notice] = I18n.t('flash.notice.not_updated', :model => @my_model_class.model_name.human)
 331       redirect_to redirect_url
 332     }
 333   end
 334
 335   def leaf_render_update ot, redirect_url
 336     if @item.store @operators, ot
 337       respond_to do |format|
 338         leaf_updated_html_format format, redirect_url
 339         updated_json_format format
 340       end
 341     else
 342       respond_to do |format|
 343         leaf_not_updated_html_format format, redirect_url
 344         not_updated_json_format format
 345       end
 346     end
 347   end
 348
 349   def destroyed_html_format format, redirect_url
 350     format.html {
 351       flash[:notice] = I18n.t('flash.notice.destroyed', :model => @my_model_class.model_name.human)
 352       redirect_to redirect_url
 353     }
 354   end
 355
 356   def destroyed_json_format format
 357     format.json {
 358       head :ok
 359     }
 360   end
 361
 362   def not_destroyed_html_format format
 363     format.html {
 364       flash[:notice] = I18n.t('flash.notice.not_destroyed', :model => @my_model_class.model_name.human)
 365       redirect_to @item
 366     }
 367   end
 368
 369   def not_destroyed_json_format format
 370     format.json {
 371       render json: @item.errors, status: :unprocessable_entity
 372     }
 373   end
 374
 375   def render_destroy redirect_url = nil
 376     if @item.destroy
 377       respond_to do |format|
 378         destroyed_html_format format, redirect_url
 379         destroyed_json_format format
 380       end
 381     else
 382       respond_to do |format|
 383         not_destroyed_html_format format
 384         not_destroyed_json_format format
 385       end
 386     end
 387   end
 388
 389   def list_count
 390     set_list
 391     j = {:count => @list.count(@operators, {:id => params[:id]})}
 392     respond_to do |format|
 393       format.json { render json: j.to_json }
 394     end
 395   end
 396
 397   def format_filer format
 398     format.html {
 399       @paginate = @@model.list_paginate(@page, @page_size)
 400       render :template => 'system/filer', :locals => {
 401         :items => @items, :model => @@model,
 402         :operators => @operators, :pager => @paginate
 403       }
 404     }
 405   end
 406
 407   def format_prof format
 408     format.prof {
 409       @profiler = self.class.profiler_manager.open(@item, @operators)
 410       render :template => 'system/prof', :locals => {
 411         :profiler => @profiler
 412       }
 413     }
 414   end
 415
 416   def assist_items item_name, list_name
 417     list = Locmare::ListGroup.list item_name, list_name
 418     list_result = list.open(@operators, {:id => @item.id, :page => 1, :page_size => 5})
 419     list_result.items
 420   end
 421
 422   def set_image(file)
 423     if file.respond_to?(:read)
 424       file.read
 425     else
 426       Base64.decode64(file.to_s.gsub(' ', '+'))
 427     end
 428   end
 429
 430   def ymd_to_time ymd_str
 431     return nil if ymd_str.blank?
 432     date = nil
 433     begin
 434       date = Time.parse(ymd_str[0..3] + '/' + ymd_str[4..5] + '/' + ymd_str[6..7])
 435     rescue
 436       date = nil
 437     end
 438     date
 439   end
 440
 441   def export_url demander_url, action, token, date
 442     u = demander_url + (demander_url[-1] == '/' ? '' : '/')
 443     prm = '?auth_token=' + token
 444     prm = prm + '&date=' + date.strftime("%Y%m%d") unless date.blank?
 445     u = URI.join(u, action + '.json' + prm)
 446     u.to_s
 447   end
 448
 449   def export_from_provider url
 450     res = nil
 451     begin
 452       json = RestClient.get url
 453       res = JSON.parse json
 454     rescue
 455     end
 456     res
 457   end
 458
 459   def export_by action, provider_status, ymd
 460     t = ymd_to_time ymd
 461     url = export_url provider_status.provider.demander_url, action, provider_status.token, t
 462     export_from_provider(url)
 463   end
 464
 465     rescue_from Pettanr::NotWork, :with => :render_not_work
 466     def render_not_work(exception = nil)
 467       if exception
 468         logger.info "Rendering , :: #{exception.message}"
 469       end
 470       respond_to do |format|
 471         format.html {
 472           render :file => "#{Rails.root}/public/not_work.html", :layout => false
 473         }
 474         format.json {
 475           render :text => "400 Not work", :status => 400
 476         }
 477       end
 478     end
 479
 480   if Rails.env == 'production'
 481     rescue_from ActiveRecord::RecordNotFound, :with => :render_404
 482     rescue_from ActiveRecord::Forbidden, :with => :render_403
 483
 484     private
 485     def render_404(exception = nil)
 486       if exception
 487         logger.info "Rendering 404: #{exception.message}"
 488       end
 489       respond_to do |format|
 490         format.html {
 491           render :file => "#{Rails.root}/public/404.html", :status => 404, :layout => false
 492         }
 493         format.json {
 494           render :text => "404 Not found", :status => 404
 495         }
 496       end
 497     end
 498
 499     def render_403(exception = nil)
 500       if exception
 501         logger.info "Rendering 403: #{exception.message}"
 502       end
 503       respond_to do |format|
 504         format.html {
 505           render :file => "#{Rails.root}/public/403.html", :status => 404, :layout => false
 506         }
 507         format.json {
 508           render :text => "403 Forbidden", :status => 403
 509         }
 510       end
 511     end
 512   end
 513 end