235 lines
6.4 KiB
Ruby
235 lines
6.4 KiB
Ruby
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
|
|
|
|
|
|
|
|
|
|
|
|
|