metamaps--metamaps/app/controllers/maps_controller.rb

304 lines
9.2 KiB
Ruby
Raw Permalink Normal View History

class MapsController < ApplicationController
before_action :require_user, only: [:create, :update, :access, :screenshot, :events, :destroy]
after_action :verify_authorized, except: [:activemaps, :featuredmaps, :mymaps, :sharedmaps, :usermaps, :events]
after_action :verify_policy_scoped, only: [:activemaps, :featuredmaps, :mymaps, :sharedmaps, :usermaps]
2014-07-31 01:10:10 +00:00
2016-02-05 09:49:59 +00:00
respond_to :html, :json, :csv
2014-07-31 01:10:10 +00:00
autocomplete :map, :name, :full => true, :extra_data => [:user_id]
# GET /explore/active
def activemaps
page = params[:page].present? ? params[:page] : 1
@maps = policy_scope(Map).order("updated_at DESC")
.page(page).per(20)
respond_to do |format|
2016-03-12 01:58:13 +00:00
format.html {
# root url => main/home. main/home renders maps/activemaps view.
redirect_to root_url and return if authenticated?
respond_with(@maps, @user)
}
format.json { render json: @maps }
end
end
# GET /explore/featured
def featuredmaps
page = params[:page].present? ? params[:page] : 1
@maps = policy_scope(
Map.where("maps.featured = ? AND maps.permission != ?",
true, "private")
).order("updated_at DESC").page(page).per(20)
respond_to do |format|
2016-02-28 05:13:44 +00:00
format.html { respond_with(@maps, @user) }
format.json { render json: @maps }
end
end
# GET /explore/mine
def mymaps
return redirect_to activemaps_url if !authenticated?
2014-07-31 01:10:10 +00:00
2016-02-09 03:26:42 +00:00
page = params[:page].present? ? params[:page] : 1
@maps = policy_scope(
Map.where("maps.user_id = ?", current_user.id)
).order("updated_at DESC").page(page).per(20)
2014-07-31 01:10:10 +00:00
respond_to do |format|
2016-02-28 05:13:44 +00:00
format.html { respond_with(@maps, @user) }
format.json { render json: @maps }
2014-07-31 01:10:10 +00:00
end
end
# GET /explore/shared
def sharedmaps
return redirect_to activemaps_url if !authenticated?
page = params[:page].present? ? params[:page] : 1
@maps = policy_scope(
Map.where("maps.id IN (?)", current_user.shared_maps.map(&:id))
).order("updated_at DESC").page(page).per(20)
respond_to do |format|
format.html { respond_with(@maps, @user) }
format.json { render json: @maps }
end
end
# GET /explore/mapper/:id
def usermaps
page = params[:page].present? ? params[:page] : 1
@user = User.find(params[:id])
@maps = policy_scope(Map.where(user: @user))
.order("updated_at DESC").page(page).per(20)
2014-07-31 01:10:10 +00:00
respond_to do |format|
2016-02-28 05:13:44 +00:00
format.html { respond_with(@maps, @user) }
2014-08-10 17:06:58 +00:00
format.json { render json: @maps }
2014-07-31 01:10:10 +00:00
end
2014-02-10 04:36:23 +00:00
end
2014-07-31 01:10:10 +00:00
# GET maps/:id
def show
@map = Map.find(params[:id])
2016-03-11 22:37:32 +00:00
authorize @map
2014-07-31 01:10:10 +00:00
2014-08-11 22:57:34 +00:00
respond_to do |format|
format.html {
2014-08-11 22:57:34 +00:00
@allmappers = @map.contributors
@allcollaborators = @map.editors
@alltopics = @map.topics.to_a.delete_if {|t| not policy(t).show? }
@allsynapses = @map.synapses.to_a.delete_if {|s| not policy(s).show? }
@allmappings = @map.mappings.to_a.delete_if {|m| not policy(m).show? }
@allmessages = @map.messages.sort_by(&:created_at)
2014-08-11 22:57:34 +00:00
respond_with(@allmappers, @allcollaborators, @allmappings, @allsynapses, @alltopics, @allmessages, @map)
2014-08-11 22:57:34 +00:00
}
format.json { render json: @map }
format.csv { redirect_to action: :export, format: :csv }
format.xls { redirect_to action: :export, format: :xls }
2014-08-11 22:57:34 +00:00
end
end
2016-03-26 03:31:55 +00:00
# GET maps/:id/export
def export
map = Map.find(params[:id])
authorize map
exporter = MapExportService.new(current_user, map)
2016-03-26 03:31:55 +00:00
respond_to do |format|
format.json { render json: exporter.json }
format.csv { send_data exporter.csv }
format.xls { @spreadsheet = exporter.xls }
end
end
# POST maps/:id/events/:event
def events
map = Map.find(params[:id])
authorize map
valid_event = false
if params[:event] == 'conversation'
Events::ConversationStartedOnMap.publish!(map, current_user)
valid_event = true
2016-04-26 12:08:12 +00:00
elsif params[:event] == 'user_presence'
Events::UserPresentOnMap.publish!(map, current_user)
valid_event = true
end
respond_to do |format|
format.json {
head :ok if valid_event
head :bad_request if not valid_event
}
end
end
2016-03-26 03:31:55 +00:00
2014-08-11 22:57:34 +00:00
# GET maps/:id/contains
def contains
@map = Map.find(params[:id])
2016-03-11 22:37:32 +00:00
authorize @map
2014-08-11 22:57:34 +00:00
@allmappers = @map.contributors
@allcollaborators = @map.editors
@alltopics = @map.topics.to_a.delete_if {|t| not policy(t).show? }
@allsynapses = @map.synapses.to_a.delete_if {|s| not policy(s).show? }
@allmappings = @map.mappings.to_a.delete_if {|m| not policy(m).show? }
2014-08-10 17:06:58 +00:00
@json = Hash.new()
@json['map'] = @map
@json['topics'] = @alltopics
@json['synapses'] = @allsynapses
@json['mappings'] = @allmappings
@json['mappers'] = @allmappers
@json['collaborators'] = @allcollaborators
@json['messages'] = @map.messages.sort_by(&:created_at)
2014-07-31 01:10:10 +00:00
respond_to do |format|
2014-08-10 17:06:58 +00:00
format.json { render json: @json }
2014-07-31 01:10:10 +00:00
end
end
2014-07-31 01:10:10 +00:00
# POST maps
def create
@user = current_user
@map = Map.new()
@map.name = params[:name]
@map.desc = params[:desc]
@map.permission = params[:permission]
@map.user = @user
@map.arranged = false
2014-07-31 01:10:10 +00:00
if params[:topicsToMap]
2016-04-20 00:51:38 +00:00
@all = params[:topicsToMap]
@all = @all.split(',')
@all.each do |topic|
topic = topic.split('/')
mapping = Mapping.new
mapping.map = @map
mapping.user = @user
mapping.mappable = Topic.find(topic[0])
mapping.xloc = topic[1]
mapping.yloc = topic[2]
authorize mapping, :create?
mapping.save
end
2014-07-31 01:10:10 +00:00
2016-04-20 00:51:38 +00:00
if params[:synapsesToMap]
@synAll = params[:synapsesToMap]
@synAll = @synAll.split(',')
@synAll.each do |synapse_id|
mapping = Mapping.new
mapping.map = @map
mapping.user = @user
mapping.mappable = Synapse.find(synapse_id)
authorize mapping, :create?
mapping.save
2014-07-31 01:10:10 +00:00
end
2016-04-20 00:51:38 +00:00
end
2014-07-31 01:10:10 +00:00
2016-04-20 00:51:38 +00:00
@map.arranged = true
2014-07-31 01:10:10 +00:00
end
2016-03-11 22:37:32 +00:00
authorize @map
2016-02-09 03:48:07 +00:00
if @map.save
respond_to do |format|
2014-07-31 01:10:10 +00:00
format.json { render :json => @map }
2016-02-09 03:48:07 +00:00
end
else
respond_to do |format|
format.json { render :json => "invalid params" }
end
2014-07-31 01:10:10 +00:00
end
end
2014-07-31 01:10:10 +00:00
# PUT maps/:id
def update
@map = Map.find(params[:id])
2016-03-11 22:37:32 +00:00
authorize @map
2014-07-31 01:10:10 +00:00
respond_to do |format|
2016-03-11 22:37:32 +00:00
if @map.update_attributes(map_params)
2014-09-11 12:35:16 +00:00
format.json { head :no_content }
else
format.json { render json: @map.errors, status: :unprocessable_entity }
end
2014-07-31 01:10:10 +00:00
end
end
2014-07-31 01:10:10 +00:00
# POST maps/:id/access
def access
@map = Map.find(params[:id])
authorize @map
userIds = params[:access] || []
added = userIds.select { |uid|
user = User.find(uid)
if user.nil? || (current_user && user == current_user)
false
else
not @map.collaborators.include?(user)
end
}
removed = @map.collaborators.select { |user| not userIds.include?(user.id.to_s) }.map(&:id)
added.each { |uid|
um = UserMap.create({ user_id: uid.to_i, map_id: @map.id })
user = User.find(uid.to_i)
MapMailer.invite_to_edit_email(@map, current_user, user).deliver_later
}
removed.each { |uid|
@map.user_maps.select{ |um| um.user_id == uid }.each{ |um| um.destroy }
}
respond_to do |format|
format.json do
render :json => { :message => "Successfully altered edit permissions" }
end
end
end
# POST maps/:id/upload_screenshot
def screenshot
@map = Map.find(params[:id])
2016-03-11 22:37:32 +00:00
authorize @map
png = Base64.decode64(params[:encoded_image]['data:image/png;base64,'.length .. -1])
StringIO.open(png) do |data|
data.class.class_eval { attr_accessor :original_filename, :content_type }
data.original_filename = "map-" + @map.id.to_s + "-screenshot.png"
data.content_type = "image/png"
@map.screenshot = data
end
if @map.save
render :json => {:message => "Successfully uploaded the map screenshot."}
else
render :json => {:message => "Failed to upload image."}
end
end
2014-07-31 01:10:10 +00:00
# DELETE maps/:id
def destroy
@map = Map.find(params[:id])
2016-03-11 22:37:32 +00:00
authorize @map
2014-07-31 01:10:10 +00:00
@map.delete
2014-07-31 01:10:10 +00:00
respond_to do |format|
format.json do
head :no_content
2014-07-31 01:10:10 +00:00
end
end
end
2015-09-19 08:26:34 +00:00
private
# Never trust parameters from the scary internet, only allow the white list through.
def map_params
2016-03-11 22:37:32 +00:00
params.require(:map).permit(:id, :name, :arranged, :desc, :permission)
2015-09-19 08:26:34 +00:00
end
end