universal_table/app/controllers/admin/universal_tables_controller.rb

class Admin::UniversalTablesController < OrbitAdminController
	def index
		@table_fields = ["universal_table.table_name","universal_table.created_time","universal_table.total_no_of_entries", "universal_table.import_from_excel"]

	    @tables = UTable.where(:title.ne => "")
						.order_by(sort)
	                    .with_categories(filters("category"))

	end

	def show
		uid = params[:id].split("-").last
		@table = UTable.where(:uid => uid).first rescue nil
		if !@table.nil?
			@columns = @table.table_columns.asc(:order)
			@table_fields = @columns.collect{|tc| tc.title}
			if params[:q].present?
				@entries = Kaminari.paginate_array(search_data(@table)).page(params[:page]).per(10)
			else
				@entries = @table.table_entries.desc(:created_at).page(params[:page]).per(10)
			end
		end
	end

	def export_structure
		uid = params[:universal_table_id].split("-").last
		@table = UTable.where(:uid => uid).first rescue nil
		respond_to do |format|
	      format.xlsx {
	        response.headers['Content-Disposition'] = "attachment; filename=#{@table.title.downcase.underscore}.xlsx"
	      }
	    end
	end

	def import_data_from_excel
		workbook = RubyXL::Parser.parse(params["import_data"].tempfile)
		response = {}
		current_locale = I18n.locale
		table = UTable.find(params["universal_table_id"]) rescue nil
		if !table.nil?
		    sheet = workbook[0]
		    if sheet.count <= 503
		    	columns = sheet[1].cells.collect{|c| 
		    		table.table_columns.where(:key => c.value).first rescue nil
		    	}
		    	languages = sheet[2].cells.collect{|c| 
		    		c.value.split("-").last rescue nil
		    	}
			    sheet.each_with_index do |row, i|
			        next if i < 3
			        te = TableEntry.new
			        te.u_table = table
			        skip = 0
			        row.cells.each_with_index do |cell,index|
			        	if skip > 1
			        		skip = skip - 1
			        		next
			        	end
			        	skip = 0
			        	val = cell.value rescue nil
			        	tc = columns[index]
			        	if !tc.nil?
			        		ce = ColumnEntry.new
			        		case tc.type
			        		when "text"
			        			v = {}
			        			@site_in_use_locales.sort.each_with_index do |locale,x|
			        				v[locale.to_s] = row.cells[index + x].value rescue nil
			        				skip = skip + 1
			        			end
			        			ce.text_translations = v
			        		when "editor"
			        			v = {}
			        			@site_in_use_locales.sort.each_with_index do |locale,x|
			        				v[locale.to_s] = row.cells[index + x].value rescue nil
			        				skip = skip + 1
			        			end
			        			ce.content_translations = v
			        		when "date"
			        			ce.date = val
			        		when "period"
			        			if tc.date_format == "yyyy" && !val.nil?
			        				val = val.to_s + "/01/01"
			        			end 
			        			skip = 2
			        			ce.period_from = val
			        			val = row.cells[index + 1].value rescue nil
			        			if tc.date_format == "yyyy" && !val.nil?
			        				val = val.to_s + "/01/01"
			        			end 
			        			ce.period_to = val
			        		end
			        		ce.table_column_id = tc.id
			        		ce.save
			      			te.column_entries << ce
			        	end
			        end
			      	te.save
			    end
			    response["success"] = true
			    response["count"] = table.table_entries.count
			    response["id"] = table.id.to_s
		    else
				response["success"] = false
				response["msg"] = "More than 500 entries. Please split the entries in different files."
		    end
		else
			response["success"] = false
			response["msg"] = "Table not found."
		end
		render :json => response.to_json
	end

	def new_entry
		uid = params[:universal_table_id].split("-").last
		@table = UTable.where(:uid => uid).first rescue nil
		if !@table.nil?
			@columns = @table.table_columns.asc(:order)
			@entries = @table.table_entries
			@entry = TableEntry.new
		end
	end

	def add_entry
		entry = TableEntry.new(table_entry_params)
		entry.save
		table = UTable.find(params[:table_entry][:u_table_id])
		redirect_to admin_universal_table_new_entry_path(table)
	end

	def edit_entry
		id = params[:universal_table_id].split("-").last
		@entry = TableEntry.where(:uid => id).first
		@table = @entry.u_table
		if !@table.nil?
			@columns = @table.table_columns.asc(:order)
			@entries = @table.table_entries
		end
	end

	def delete_entry
		entry = TableEntry.find(params[:universal_table_id])
		table = entry.u_table
		entry.destroy
		redirect_to admin_universal_table_path(table)
	end

	def update_entry
		entry = TableEntry.find(params[:id])
		entry.update_attributes(table_entry_params)
		table = entry.u_table
		redirect_to admin_universal_table_path(table)
	end

	def new
		@table = UTable.new
	end

	def create
		category = Category.new
		category.title_translations = params[:u_table][:title_translations]
		category.module_app = @module_app
		category.save
		p = table_params
		p[:category_id] = category.id
		table = UTable.new(p)
		table.save
		redirect_to admin_universal_tables_path
	end

	def edit
		uid = params[:id].split("-").last
		@table = UTable.where(:uid => uid).first
	end

	def update
		uid = params[:id].split("-").last
		p = table_params
		table = UTable.where(:uid => uid).first
		cat = table.category rescue nil
		if cat.nil?
			cat = Category.new
			cat.module_app = @module_app
		end
		cat.title_translations = p[:title_translations]
		cat.save
		p[:category_id] = cat.id
		table.update_attributes(p)
		table.save
		redirect_to admin_universal_tables_path
	end

	def destroy
		uid = params[:id].split("-").last
		table = UTable.where(:uid => uid).first
		table.category.destroy
		table.destroy
		redirect_to admin_universal_tables_path
	end

	private

	def search_data(table)
		keywords = params["q"]
		keywords = keywords.strip.nil? ? keywords : keywords.strip
		regexes = keywords.split(/\s+(?=(?:[^"]*"[^"]*")*[^"]*$)/)
		regex = Regexp.union(regexes.map{|word| Regexp.new(".*"+word+".*", "i")})

		column = table.table_columns.where(:type.in => ["text","editor"])
		columns = []
		column.each do |c|
			columns = (columns | c.column_entries.any_of(:"text.en" => regex).or(:"text.zh_tw" => regex).or(:"content.en" => regex).or(:"content.zh_tw" => regex))
		end
		entries = []
		columns.each do |column|
			entries << column.table_entry
		end
		entries = entries.sort{|k,v| v["created_at"] <=> k["created_at"]}
	end

	def table_params
		params.require(:u_table).permit!
	end

	def table_entry_params
		params.require(:table_entry).permit!
	end
end