app/controllers/application_controller.rb

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