lib/attachment_to_html/attachment_to_html.rb

# app/controllers/admin_request_controller.rb:
# Controller for viewing FOI requests from the admin interface.
#
# Copyright (c) 2007 UK Citizens Online Democracy. All rights reserved.
# Email: francis@mysociety.org; WWW: http://www.mysociety.org/
#
# $Id: admin_request_controller.rb,v 1.42 2009-10-03 01:28:33 francis Exp $

class AdminRequestController < AdminController
    def index
        list
        render :action => 'list'
    end

    def list
        @query = params[:query]
        @info_requests = InfoRequest.paginate :order => "created_at desc", :page => params[:page], :per_page => 100,
            :conditions =>  @query.nil? ? nil : ["lower(title) like lower('%'||?||'%')", @query]
    end

    def list_old_unclassified
        @info_requests = InfoRequest.find_old_unclassified(:conditions => ["prominence = 'normal'"])
    end

    def show
        @info_request = InfoRequest.find(params[:id])
    end

    def resend
        @outgoing_message = OutgoingMessage.find(params[:outgoing_message_id])
        @outgoing_message.resend_message
        flash[:notice] = "Outgoing message resent"
        redirect_to request_admin_url(@outgoing_message.info_request)
    end

    def edit
        @info_request = InfoRequest.find(params[:id])
    end

    def update
        @info_request = InfoRequest.find(params[:id])

        old_title = @info_request.title
        old_prominence = @info_request.prominence
        old_described_state = @info_request.described_state
        old_awaiting_description = @info_request.awaiting_description
        old_allow_new_responses_from = @info_request.allow_new_responses_from
        old_handle_rejected_responses = @info_request.handle_rejected_responses
        old_tag_string = @info_request.tag_string

        @info_request.title = params[:info_request][:title]
        @info_request.prominence = params[:info_request][:prominence]
        if @info_request.described_state != params[:info_request][:described_state]
            @info_request.set_described_state(params[:info_request][:described_state])
        end
        @info_request.awaiting_description = params[:info_request][:awaiting_description] == "true" ? true : false
        @info_request.allow_new_responses_from = params[:info_request][:allow_new_responses_from]
        @info_request.handle_rejected_responses = params[:info_request][:handle_rejected_responses]
        @info_request.tag_string = params[:info_request][:tag_string]

        if @info_request.valid?
            @info_request.save!
            @info_request.log_event("edit", 
                { :editor => admin_http_auth_user(), 
                    :old_title => old_title, :title => @info_request.title, 
                    :old_prominence => old_prominence, :prominence => @info_request.prominence, 
                    :old_described_state => old_described_state, :described_state => @info_request.described_state,
                    :old_awaiting_description => old_awaiting_description, :awaiting_description => @info_request.awaiting_description,
                    :old_allow_new_responses_from => old_allow_new_responses_from, :allow_new_responses_from => @info_request.allow_new_responses_from,
                    :old_handle_rejected_responses => old_handle_rejected_responses, :handle_rejected_responses => @info_request.handle_rejected_responses,
                    :old_tag_string => old_tag_string, :tag_string => @info_request.tag_string
                })
            flash[:notice] = 'Request successfully updated.'
            redirect_to request_admin_url(@info_request)
        else
            render :action => 'edit'
        end
    end 

    def fully_destroy
        @info_request = InfoRequest.find(params[:id])

        user = @info_request.user
        url_title = @info_request.url_title

        @info_request.fully_destroy

        flash[:notice] = "Request #{url_title} has been completely destroyed. Email of user who made request: " + user.email
        redirect_to admin_url('request/list')
    end

    def edit_outgoing
        @outgoing_message = OutgoingMessage.find(params[:id])
    end

    def destroy_outgoing
        @outgoing_message = OutgoingMessage.find(params[:outgoing_message_id])
        @info_request = @outgoing_message.info_request
        outgoing_message_id = @outgoing_message.id

        @outgoing_message.fully_destroy
        @outgoing_message.info_request.log_event("destroy_outgoing", 
            { :editor => admin_http_auth_user(), :deleted_outgoing_message_id => outgoing_message_id })

        flash[:notice] = 'Outgoing message successfully destroyed.'
        redirect_to request_admin_url(@info_request)
    end 

    def update_outgoing
        @outgoing_message = OutgoingMessage.find(params[:id])

        old_body = @outgoing_message.body

        if @outgoing_message.update_attributes(params[:outgoing_message]) 
            @outgoing_message.info_request.log_event("edit_outgoing", 
                { :outgoing_message_id => @outgoing_message.id, :editor => admin_http_auth_user(), 
                    :old_body => old_body, :body => @outgoing_message.body })
            flash[:notice] = 'Outgoing message successfully updated.'
            redirect_to request_admin_url(@outgoing_message.info_request)
        else
            render :action => 'edit_outgoing'
        end
    end 

    def edit_comment
        @comment = Comment.find(params[:id])
    end

    def update_comment
        @comment = Comment.find(params[:id])

        old_body = @comment.body
        old_visible = @comment.visible
        @comment.visible = params[:comment][:visible] == "true" ? true : false

        if @comment.update_attributes(params[:comment]) 
            @comment.info_request.log_event("edit_comment", 
                { :comment_id => @comment.id, :editor => admin_http_auth_user(), 
                    :old_body => old_body, :body => @comment.body,
                    :old_visible => old_visible, :visible => @comment.visible,
                })
            flash[:notice] = 'Comment successfully updated.'
            redirect_to request_admin_url(@comment.info_request)
        else
            render :action => 'edit_comment'
        end
    end 


    def destroy_incoming
        @incoming_message = IncomingMessage.find(params[:incoming_message_id])
        @info_request = @incoming_message.info_request
        incoming_message_id = @incoming_message.id

        @incoming_message.fully_destroy
        @incoming_message.info_request.log_event("destroy_incoming", 
            { :editor => admin_http_auth_user(), :deleted_incoming_message_id => incoming_message_id })

        flash[:notice] = 'Incoming message successfully destroyed.'
        redirect_to request_admin_url(@info_request)
    end 

    def redeliver_incoming
        incoming_message = IncomingMessage.find(params[:redeliver_incoming_message_id])

        if params[:url_title].match(/^[0-9]+$/)
            destination_request = InfoRequest.find(params[:url_title].to_i)
        else
            destination_request = InfoRequest.find_by_url_title(params[:url_title])
        end

        if destination_request.nil?
            flash[:error] = "Failed to find destination request '" + params[:url_title] + "'"
            redirect_to request_admin_url(incoming_message.info_request)
        end

        raw_email_data = incoming_message.raw_email.data
        mail = TMail::Mail.parse(raw_email_data)
        mail.base64_decode
        destination_request.receive(mail, raw_email_data)

        incoming_message_id = incoming_message.id
        incoming_message.fully_destroy
        incoming_message.info_request.log_event("redeliver_incoming", { 
                :editor => admin_http_auth_user(), 
                :destination_request => destination_request.id, 
                :deleted_incoming_message_id => incoming_message_id 
        })

        flash[:notice] = "Message has been moved to this request"
        redirect_to request_admin_url(destination_request)
    end

    # change user or public body of a request magically
    def move_request
        info_request = InfoRequest.find(params[:info_request_id])
        if params[:commit] == 'Move request to user' && !params[:user_url_name].blank?
            old_user = info_request.user
            destination_user = User.find_by_url_name(params[:user_url_name])
            if destination_user.nil?
                flash[:error] = "Couldn't find user '" + params[:user_url_name] + "'"
            else
                info_request.user = destination_user
                info_request.save!
                info_request.log_event("move_request", { 
                        :editor => admin_http_auth_user(), 
                        :old_user_url_name => old_user.url_name, 
                        :user_url_name => destination_user.url_name 
                })

                info_request.reindex_request_events
                flash[:notice] = "Message has been moved to new user"
            end
            redirect_to request_admin_url(info_request)
        elsif params[:commit] == 'Move request to authority' && !params[:public_body_url_name].blank?
            old_public_body = info_request.public_body
            destination_public_body = PublicBody.find_by_url_name(params[:public_body_url_name])
            if destination_public_body.nil?
                flash[:error] = "Couldn't find public body '" + params[:public_body_url_name] + "'"
            else
                info_request.public_body = destination_public_body
                info_request.save!
                info_request.log_event("move_request", { 
                        :editor => admin_http_auth_user(), 
                        :old_public_body_url_name => old_public_body.url_name, 
                        :public_body_url_name => destination_public_body.url_name 
                })

                info_request.reindex_request_events
                flash[:notice] = "Request has been moved to new body"
            end

            redirect_to request_admin_url(info_request)
        else
            flash[:error] = "Please enter the user or authority to move the request to"
            redirect_to request_admin_url(info_request)
        end
    end

    def generate_upload_url
        info_request = InfoRequest.find(params[:id])

        if params[:incoming_message_id]
            incoming_message = IncomingMessage.find(params[:incoming_message_id])
            email = incoming_message.mail.from_addrs[0].address
            name = incoming_message.safe_mail_from || info_request.public_body.name
        else
            email = info_request.public_body.request_email
            name = info_request.public_body.name
        end

        user = User.find_user_by_email(email)
        if not user
            user = User.new(:name => name, :email => email, :password => PostRedirect.generate_random_token)
            user.save!
        end

        if !info_request.public_body.is_foi_officer?(user)
            flash[:notice] = user.email + " is not an email at the domain @" + info_request.public_body.foi_officer_domain_required + ", so won't be able to upload."
            redirect_to request_admin_url(info_request)
            return
        end

        # Bejeeps, look, sometimes a URL is something that belongs in a controller, jesus.
        # XXX hammer this square peg into the round MVC hole - should be calling main_url(upload_response_url())
        post_redirect = PostRedirect.new(
            :uri => main_url(upload_response_url(:url_title => info_request.url_title, :only_path => true)),
            :user_id => user.id)
        post_redirect.save!
        url = main_url(confirm_url(:email_token => post_redirect.email_token, :only_path => true))

        flash[:notice] = 'Send "' + name + '" &lt;<a href="mailto:' + email + '">' + email + '</a>&gt; this URL: <a href="' + url + '">' + url + "</a> - it will log them in and let them upload a response to this request."
        redirect_to request_admin_url(info_request)
    end

    def show_raw_email
        @raw_email = RawEmail.find(params[:id])

        # For the holding pen, try to guess where it should be ...
        @holding_pen = false
        if (@raw_email.incoming_message.info_request == InfoRequest.holding_pen_request && !@raw_email.incoming_message.mail.from_addrs.nil? && @raw_email.incoming_message.mail.from_addrs.size > 0)
            @holding_pen = true

            # 1. Use domain of email to try and guess which public body it
            # is associated with, so we can display that.
            email = @raw_email.incoming_message.mail.from_addrs[0].spec
            domain = PublicBody.extract_domain_from_email(email)

            if domain.nil?
                @public_bodies = []
            else
                @public_bodies = PublicBody.find(:all, :order => "name", 
                    :conditions => [ "lower(request_email) like lower('%'||?||'%')", domain ])
            end
            
            # 2. Match the email address in the message without matching the hash
            @info_requests = []
            addresses =
                    (@raw_email.incoming_message.mail.to || []) + 
                    (@raw_email.incoming_message.mail.cc || []) +
                    (@raw_email.incoming_message.mail.envelope_to || [])
            addresses.uniq!
            for address in addresses
                @info_requests += InfoRequest.guess_by_incoming_email(address)
            end
        end
    end

    def download_raw_email
        @raw_email = RawEmail.find(params[:id])

        response.content_type = 'message/rfc822'
        render :text => @raw_email.data
    end

    # used so due dates get fixed
    def mark_event_as_clarification
        info_request_event = InfoRequestEvent.find(params[:info_request_event_id])
        if info_request_event.event_type != 'response'
            raise Exception("can only mark responses as requires clarification")
        end
        info_request_event.described_state = 'waiting_clarification'
        info_request_event.calculated_state = 'waiting_clarification'
        # XXX deliberately don't update described_at so doesn't reenter search?
        info_request_event.save!

        flash[:notice] = "Old response marked as having been a clarification"
        redirect_to request_admin_url(info_request_event.info_request)
    end

    private

end
	Commit message (Expand)	Author	Age	Lines
*	Dynamically inject AttachmentToHTML::View content	Gareth Rees	2014-04-07	-1/+5
*	Remove redundant AttachmentToHTML::HTML	Gareth Rees	2014-04-07	-1/+0
*	Update AttachmentToHTML for new View class	Gareth Rees	2014-04-07	-6/+7
*	Add an AttachmentToHTML::View to deal with rendering	Gareth Rees	2014-04-07	-0/+1
*	Add AttachmentToHTML library	Gareth Rees	2014-03-28	-0/+41