420 lines
13 KiB
Ruby
420 lines
13 KiB
Ruby
class Admin::RulingTimersController < OrbitMemberController
|
|
include Admin::RulingTimersHelper
|
|
before_action :check_permissions, :set_weekdays, :set_setting
|
|
before_action :set_projects , :only => [:project_management,:add_task,:edit_task]
|
|
before_action :set_tags, :only => [:index, :task_management, :project_management, :add_task,:edit_task]
|
|
def check_permissions
|
|
@is_manager = false
|
|
OrbitHelper.set_params(params,current_user)
|
|
access_level = OrbitHelper.user_access_level?
|
|
if (access_level.nil? || access_level == "user")
|
|
@setting = RulingTimerSetting.first
|
|
unless @setting.authorize?(current_user)
|
|
render_401
|
|
end
|
|
else
|
|
@is_manager = true
|
|
end
|
|
end
|
|
def set_type_params
|
|
all_types = ["all_tasks","my_tasks","my_assisted_tasks","my_observed_tasks"]
|
|
type = params[:type]
|
|
if !all_types.include?(type)
|
|
if @is_manager
|
|
type = all_types[0]
|
|
else
|
|
type = all_types[1]
|
|
end
|
|
end
|
|
case type
|
|
when "all_tasks"
|
|
@tasks = @tasks
|
|
when "my_tasks"
|
|
@tasks = @tasks.where(:owner=>current_user)
|
|
when "my_assisted_tasks"
|
|
@tasks = @tasks.where(:helper_ids=>current_user.id.to_s)
|
|
when "my_observed_tasks"
|
|
@tasks = @tasks.where(:observer_ids=>current_user.id.to_s)
|
|
end
|
|
end
|
|
def initialize
|
|
super
|
|
@app_title = "ruling_timer"
|
|
end
|
|
def index
|
|
user = current_user
|
|
get_user_timer_data(user)
|
|
end
|
|
def timer_management
|
|
@timer_temps = RulingTimerTemp.all.page(params[:page]).per(15)
|
|
@active_users = @timer_temps.map{|t| t.user}
|
|
end
|
|
def task_management
|
|
@tasks = RulingTimerTask.all.desc(:created_at).page(params[:page]).per(10)
|
|
set_type_params
|
|
end
|
|
def project_management
|
|
end
|
|
def work_history
|
|
user = User.find(params[:id]) rescue nil
|
|
get_user_timer_data(user,true)
|
|
render "index"
|
|
end
|
|
def set_projects
|
|
@categories = current_user.approved_categories.select{|c| c.module_app_id == @module_app.id} rescue []
|
|
@task = nil
|
|
@private_project_id = nil
|
|
if params[:action] == "edit_task"
|
|
@task = RulingTimerTask.find(params[:id])
|
|
@private_project_id = RulingTimerProject.where(:is_private=>true,:creator=>@task.creator).pluck(:id).first #私人專案
|
|
else
|
|
@private_project_id = RulingTimerProject.where(:is_private=>true,:creator=>current_user).pluck(:id).first #私人專案
|
|
end
|
|
@projects = RulingTimerProject.any_of({:is_hidden=>false,:category_id.in=>@categories.collect(&:id)},{:id=>@private_project_id}).desc(:created_at)
|
|
if params[:action] == "project_management"
|
|
@projects = @projects.page(params[:page]).per(10)
|
|
else
|
|
@projects = @projects.to_a
|
|
if @private_project_id.nil?
|
|
@projects = [RulingTimerProject.new] + @projects
|
|
end
|
|
end
|
|
end
|
|
def get_user_timer_data(user, display_name = false)
|
|
time_now = DateTime.now.utc.new_offset("+8")
|
|
now_year_month = time_now.strftime("%Y/%m")
|
|
@start_year_month = params[:start_year_month].present? ? DateTime.parse(params[:start_year_month]).utc : time_now
|
|
@end_year_month = params[:end_year_month].present? ? DateTime.parse(params[:end_year_month]).utc : time_now
|
|
@all_year_months = []
|
|
tmp = @start_year_month.clone
|
|
while tmp <= @end_year_month do
|
|
@all_year_months << tmp.strftime("%Y/%m")
|
|
tmp += 1.month
|
|
end
|
|
@all_year_months_data = @all_year_months.map do |ym|
|
|
tmp = RulingTimerTemp.where(:user=>user,:date=>/#{ym.sub("/","\\/")}/).first
|
|
all_infos = []
|
|
if tmp
|
|
all_infos << {:date=>tmp.date.split(" ")[0],:seconds=>tmp.calc("work_times"),:work_time_str=>tmp.transform_second_to_time(tmp.all_work_times_seconds)}
|
|
end
|
|
all_infos += RulingTimerHistory.where(:user=>user,:date=>/#{ym.sub("/","\\/")}/).desc(:created_at).pluck(:date,:all_work_times_seconds,:work_time_str).map{|d,t,str| {:date=> d.split(" ")[0],:seconds=>t,:work_time_str=>str}}
|
|
[ym, all_infos.inject(0){|sum,h| sum + h[:seconds] } , all_infos]
|
|
end
|
|
@ruling_timer_temp = RulingTimerTemp.where(:user=>user).first
|
|
@ruling_timer_history = []
|
|
all_count = 0
|
|
per = 10
|
|
page = params[:page].to_i
|
|
if @ruling_timer_temp
|
|
@ruling_timer_history = RulingTimerHistory.where(:user=>user).desc(:created_at)
|
|
all_count += (1 + @ruling_timer_history.count)
|
|
if page <= 1
|
|
@ruling_timer_history = @ruling_timer_history.page(0).per(per - 1)
|
|
else
|
|
@ruling_timer_history = @ruling_timer_history.limit(per).skip(per * page - 1)
|
|
@ruling_timer_temp = nil
|
|
end
|
|
end
|
|
@ruling_pager = RulingPager.new(:count=>all_count,:page=>page,:per=>per)
|
|
@user_name = user.name if display_name
|
|
end
|
|
def edit_temp_timer
|
|
@timer = RulingTimerTemp.find(params[:id]) rescue nil
|
|
if @timer.nil?
|
|
redirect_to admin_ruling_timers_path and return
|
|
end
|
|
render "edit_timer"
|
|
end
|
|
def edit_timer
|
|
@timer = RulingTimerHistory.find(params[:id]) rescue nil
|
|
if @timer.nil?
|
|
redirect_to admin_ruling_timers_path and return
|
|
end
|
|
end
|
|
def update_timer
|
|
@timer = nil
|
|
if params[:type] == "temp"
|
|
@timer = RulingTimerTemp.find(params[:id])
|
|
else
|
|
@timer = RulingTimerHistory.find(params[:id])
|
|
end
|
|
@timer_params = timer_params
|
|
date = @timer.date.split(" ")[0]
|
|
@timer_params[:work_times] = @timer_params[:work_times].to_a.map do |t|
|
|
if t.blank?
|
|
nil
|
|
else
|
|
DateTime.parse("#{date} #{t}#{@timer.time_offset}").utc
|
|
end
|
|
end.compact
|
|
@timer.update_attributes(@timer_params)
|
|
@timer.fix_work_times
|
|
redirect_to params[:referer_url]
|
|
end
|
|
def add_task
|
|
@no_comment_save_btn = true
|
|
@task = RulingTimerTask.new(:owner=>current_user,:ruling_timer_project_id=>@private_project_id)
|
|
if params[:project_id]
|
|
@task.ruling_timer_project_id = params[:project_id]
|
|
end
|
|
@project = @task.ruling_timer_project
|
|
@users = User.where(:member_profile_id.in=>MemberProfile.where(:role_ids.in=>@setting.role_ids).pluck(:id))
|
|
end
|
|
def edit_task
|
|
@no_comment_save_btn = true
|
|
@users = User.where(:member_profile_id.in=>MemberProfile.where(:role_ids.in=>@setting.role_ids).pluck(:id))
|
|
@project = nil
|
|
if params[:project_id]
|
|
@project = RulingTimerProject.find(params[:project_id])
|
|
else
|
|
@project = @task.ruling_timer_project
|
|
end
|
|
end
|
|
def create_task
|
|
@task = RulingTimerTask.new(task_params)
|
|
@task.creator = current_user
|
|
@task.update_user_id = current_user.id
|
|
@task.save
|
|
redirect_to params[:referer_url]
|
|
end
|
|
def update_task
|
|
@task = RulingTimerTask.find(params[:id])
|
|
@task.update_user_id = current_user.id
|
|
@task.update_attributes(task_params)
|
|
@task.save
|
|
redirect_to params[:referer_url]
|
|
end
|
|
def delete_task
|
|
if params[:confirm_delete]
|
|
RulingTimerTask.where(:id=>params[:id]).destroy
|
|
render :json => {:success=>true}
|
|
end
|
|
end
|
|
def view_task
|
|
@task = nil
|
|
if params[:type] == "sub_task"
|
|
@task = RulingTimerSubTask.find(params[:id]).ruling_timer_task
|
|
else
|
|
@task = RulingTimerTask.find(params[:id])
|
|
end
|
|
end
|
|
def delete_history
|
|
if params[:confirm_delete]
|
|
if params[:type] == 'temp'
|
|
RulingTimerTemp.where(:id=>params[:id]).destroy
|
|
else
|
|
RulingTimerHistory.where(:id=>params[:id]).destroy
|
|
end
|
|
render :json => {:success=>true}
|
|
end
|
|
end
|
|
def add_history
|
|
@user = nil
|
|
if params[:id] == "current_user"
|
|
params[:id] = current_user.id.to_s
|
|
@user = current_user
|
|
else
|
|
@user = User.find(params[:id])
|
|
end
|
|
@history = RulingTimerHistory.new(:user_id=>params[:id])
|
|
end
|
|
def add_project
|
|
@project = RulingTimerProject.new(:project_manager=>current_user)
|
|
@categories = current_user.approved_categories.select{|c| c.module_app_id == @module_app.id} rescue []
|
|
@users = User.where(:member_profile_id.in=>MemberProfile.where(:role_ids.in=>@setting.role_ids).pluck(:id))
|
|
end
|
|
def edit_project
|
|
@project = RulingTimerProject.find(params[:id])
|
|
@categories = current_user.approved_categories.select{|c| c.module_app_id == @module_app.id} rescue []
|
|
@users = User.where(:member_profile_id.in=>MemberProfile.where(:role_ids.in=>@setting.role_ids).pluck(:id))
|
|
end
|
|
def create_project
|
|
@project = RulingTimerProject.new(project_params.merge({:creator=>current_user}))
|
|
@project.save
|
|
redirect_to params[:referer_url]
|
|
end
|
|
def update_project
|
|
@project = RulingTimerProject.find(params[:id])
|
|
@project.update_attributes(project_params)
|
|
redirect_to params[:referer_url]
|
|
end
|
|
def delete_project
|
|
if params[:confirm_delete]
|
|
RulingTimerProject.where(:id=>params[:id]).destroy
|
|
render :json => {:success=>true}
|
|
end
|
|
end
|
|
def view_project
|
|
@project = RulingTimerProject.find(params[:id])
|
|
@tasks = @project.ruling_timer_tasks.desc(:created_at).page(params[:page]).per(10)
|
|
set_type_params
|
|
render "task_management"
|
|
end
|
|
def create_history
|
|
@history_params = history_params
|
|
user = User.find(@history_params[:user_id])
|
|
@old_historys = RulingTimerHistory.where(:date=>@history_params[:date],:user=>user).to_a + RulingTimerTemp.where(:date=>@history_params[:date],:user=>user).to_a
|
|
if @old_historys.count == 0
|
|
if RulingTimerTemp.where(:user=>user).count == 0
|
|
@history = RulingTimerTemp.create(@history_params)
|
|
else
|
|
@history = RulingTimerHistory.create(@history_params)
|
|
end
|
|
@history.recalc_all
|
|
@history.fix_work_times
|
|
else
|
|
@old_history = @old_historys.first
|
|
@old_history.merge_work_times(@history_params[:work_times])
|
|
end
|
|
redirect_to params[:referer_url]
|
|
end
|
|
def section_management
|
|
@project = RulingTimerProject.find(params[:id])
|
|
@sections = @project.ruling_timer_sections.page(params[:page]).per(10)
|
|
if request.xhr?
|
|
render :partial => "sections_content"
|
|
end
|
|
end
|
|
def add_section
|
|
@section = RulingTimerSection.new(:ruling_timer_project_id=>params[:id])
|
|
render :layout => false
|
|
end
|
|
def edit_section
|
|
@section = RulingTimerSection.find(params[:id])
|
|
render :layout => false
|
|
end
|
|
def update_section
|
|
@section = RulingTimerSection.find(params[:id])
|
|
@section.update_attributes(section_params)
|
|
render :json => {:success => true}
|
|
end
|
|
def create_section
|
|
@section = RulingTimerSection.create(section_params)
|
|
render :json => {:success => true}
|
|
end
|
|
def delete_section
|
|
if params[:confirm_delete]
|
|
RulingTimerSection.where(:id=>params[:id]).destroy
|
|
render :json => {:success=>true}
|
|
end
|
|
end
|
|
def save_comment
|
|
if params["task_id"]
|
|
@comment = nil
|
|
@task = RulingTimerTask.find(params["task_id"])
|
|
i = 0
|
|
if params["id"]
|
|
@comment = RulingTimerComment.where(:id=>params["id"]).first
|
|
end
|
|
if @comment.nil?
|
|
@comment = RulingTimerComment.new(:ruling_timer_task_id=>params["task_id"])
|
|
i = @task.ruling_timer_comments.count
|
|
else
|
|
i = @task.ruling_timer_comments.find_index{|c| c.id.to_s == params["id"]}
|
|
end
|
|
@comment.content = params["content"]
|
|
@comment.save
|
|
html = nil
|
|
f = RulingFormHelper.new
|
|
f.fields_for :task,@task do |f|
|
|
f.fields_for :ruling_timer_comments, @comment do |f|
|
|
html = render_to_string(:partial=>"form_comment", :object => @comment ,:locals=>{:f=>f,:i=>i})
|
|
end
|
|
end
|
|
render :json => {:success=>true,:id=>@comment.id.to_s, :html => html}
|
|
end
|
|
end
|
|
def delete_comment
|
|
if params["id"]
|
|
RulingTimerComment.where(:id=>params["id"]).destroy
|
|
end
|
|
puts params
|
|
render :json => {:success=>true}
|
|
end
|
|
def section_params
|
|
section_params = params.require(:ruling_timer_section).permit!
|
|
end
|
|
def history_params
|
|
history_params = params.require(:ruling_timer_history).permit!
|
|
date = history_params[:date]
|
|
time_offset = history_params[:time_offset]
|
|
history_params[:work_times] =[] if history_params[:work_times].nil?
|
|
first_time = history_params[:work_times].first
|
|
first_time = "00:00:00" if first_time.blank?
|
|
history_params[:work_times] = history_params[:work_times].map do |t|
|
|
if t.blank?
|
|
nil
|
|
else
|
|
DateTime.parse("#{date} #{t}#{time_offset}").utc
|
|
end
|
|
end.compact
|
|
history_params[:date] = DateTime.parse(date).strftime("%Y/%m/%d %w")
|
|
history_params[:created_at] = DateTime.parse(date + " " + first_time + time_offset).utc
|
|
history_params
|
|
end
|
|
def task_params
|
|
task_params = params.require(:ruling_timer_task).permit!
|
|
end
|
|
def project_params
|
|
project_params = params.require(:ruling_timer_project).permit!
|
|
project_params[:all_user_ids] = [] if project_params[:all_user_ids].nil?
|
|
project_params
|
|
end
|
|
def timer_params
|
|
if params[:type] == "temp"
|
|
params.require(:ruling_timer_temp).permit!
|
|
else
|
|
params.require(:ruling_timer_history).permit!
|
|
end
|
|
end
|
|
def set_weekdays
|
|
@weekdays = ["sunday","monday","tuesday","wednesday","thursday","friday","saturday"]
|
|
@weekdays.map!{|d| I18n.t("ruling_timer.week_days.#{d}")}
|
|
end
|
|
def settings
|
|
@roles = Role.all
|
|
end
|
|
def update_setting
|
|
@setting.update_attributes(setting_params)
|
|
redirect_to settings_admin_ruling_timers_path and return
|
|
end
|
|
def set_setting
|
|
@module_app = ModuleApp.where(:key=>@app_title).first
|
|
if @module_app.nil?
|
|
@module_app = OrbitMemberModule.where(:key=>@app_title).first
|
|
end
|
|
@setting = RulingTimerSetting.first
|
|
if @setting.nil?
|
|
@setting = RulingTimerSetting.create
|
|
end
|
|
end
|
|
def set_tags
|
|
@tags = @module_app.tags
|
|
end
|
|
def setting_params
|
|
params.require(:ruling_timer_setting).permit!
|
|
end
|
|
class RulingPager
|
|
attr_accessor :count,:page,:per
|
|
def initialize(attrs)
|
|
if attrs.class == Hash
|
|
attrs.each do |k,v|
|
|
self.send("#{k}=",v)
|
|
end
|
|
end
|
|
end
|
|
def current_page
|
|
self.page.to_i
|
|
end
|
|
def limit_value
|
|
self.per
|
|
end
|
|
def total_pages
|
|
(self.count / self.per).ceil
|
|
end
|
|
end
|
|
class RulingFormHelper
|
|
include ActionView::Helpers::FormHelper
|
|
include ActionView::Context
|
|
end
|
|
end |