answers-core 0.0.0

data/app/controllers/answers/answers_controller.rb

@@ -0,0 +1,26 @@
+module Answers
+  class AnswersController < Answers::ApplicationController
+  before_action :set_answer, only: [:show]
+  respond_to :html
+
+  def index
+    @answers = Answer.all
+    respond_with(@answers)
+  end
+
+  def show
+    respond_with(@answer)
+  end
+
+  private
+    def set_answer
+      @answer = Answer.find(params[:id])
+    end
+
+    def answer_params
+      #params.require(:user).permit(:username, :email, :password, :salt, :encrypted_password)
+      #params[:answer]
+      params.require(:answer).permit(:text, :in_language, :need_to_know)
+    end
+  end
+end

data/app/controllers/answers/api/v1/answers_controller.rb

@@ -0,0 +1,38 @@
+module Answers
+  class Api::V1::AnswersController < Answers::Api::V1::ApiController
+    respond_to :json
+
+    def index
+      answers = Answer.all
+      render locals: {answers: answers}
+    end
+
+    def show
+      answer = Answer.find(params[:id])
+      render locals: {answer: answer}
+    end
+  
+    def create
+      answer = Answer.new(answer_params)
+      answer.save
+      render 'answers/show', locals: {answer: answer}
+    end
+
+    def update
+      answer = Answer.find(params[:id])
+      answer.update(answer_params)
+      render 'answers/show', locals: {answer: answer}
+    end
+
+    def destroy
+      answer = Answer.find(params[:id])
+      answer.destroy
+      render 'answers/show', locals: {answer: answer}
+    end
+
+    private
+      def answer_params
+        params.require(:answer).permit(:text, :in_language, :need_to_know, :question_id)
+      end
+  end
+end

data/app/controllers/answers/api/v1/api_controller.rb

@@ -0,0 +1,13 @@
+module Answers
+  class Api::V1::ApiController < ApplicationController
+   #acts_as_token_authentication_handler_for ::User, only: [:create, :update, :destroy]
+    prepend_view_path "app/answers/views/api/v1"
+    rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+  
+    private
+  
+      def record_not_found
+        render json: {message: '404 Not Found', status: 404}, status: 404
+      end
+  end
+end

data/app/controllers/answers/api/v1/questions_controller.rb

@@ -0,0 +1,39 @@
+module Answers
+  class Api::V1::QuestionsController < Api::V1::ApiController
+    respond_to :json
+
+    def index
+      questions = Question.all
+      render locals: {questions: questions}
+    end
+
+    def show
+      question = Question.find(params[:id])
+      render locals: {question: question}
+    end
+  
+    def create
+      question = Question.new(question_params)
+      question.save
+      render 'questions/show', locals: {question: question}
+    end
+
+    def update
+      question = Question.find(params[:id])
+      question.update(question_params)
+      render 'questions/show', locals: {question: question}
+    end
+
+    def destroy
+      question = Question.find(params[:id])
+      question.destroy
+      render 'questions/show', locals: {question: question}
+    end
+
+    private
+
+      def question_params
+        params.require(:question).permit(:text, :in_language)
+      end
+  end
+end

data/app/controllers/answers/api/v1/taggings_controller.rb

@@ -0,0 +1,46 @@
+module Answers
+  class Api::V1::TaggingsController < Answers::Api::V1::ApiController
+    respond_to :json
+
+    def index
+      taggings = ActsAsTaggableOn::Tagging.all
+      render locals: {taggings: taggings}
+    end
+
+    def show
+      puts "SHOW!!!"
+      tagging = ActsAsTaggableOn::Tagging.find(params[:id])
+      render locals: {tagging: tagging}
+    end
+  
+    def create
+      tagging = ActsAsTaggableOn::Tagging.new(tagging_params)
+      tagging.save
+      render 'tagging/show', locals: {tag: tagging}
+    end
+
+    def update
+      tag = ActsAsTaggableOn::Tagging.find(params[:id])
+      tag.update(tag_params)
+      render 'tagging/show', locals: {tagging: tagging}
+    end
+
+    def destroy
+      tagging = ActsAsTaggableOn::Tagging.find(params[:id])
+      tagging.destroy
+      render 'tagging/show', locals: {tagging: tagging}
+    end
+
+    private
+      def tagging_params
+        params.require(:tagging).permit(
+          :tag_id,
+          :taggable_id,
+          :taggable_type,
+          :tagger_id,
+          :tagger_type,
+          :context
+        )
+      end
+  end
+end

data/app/controllers/answers/api/v1/tags_controller.rb

@@ -0,0 +1,38 @@
+module Answers
+  class Api::V1::TagsController < Answers::Api::V1::ApiController
+    respond_to :json
+
+    def index
+      tags = ActsAsTaggableOn::Tag.all
+      render locals: {tags: tags}
+    end
+
+    def show
+      tag = ActsAsTaggableOn::Tag.find(params[:id])
+      render locals: {tag: tag}
+    end
+  
+    def create
+      tag = ActsAsTaggableOn::Tag.new(tag_params)
+      tag.save
+      render 'tags/show', locals: {tag: tag}
+    end
+
+    def update
+      tag = ActsAsTaggableOn::Tag.find(params[:id])
+      tag.update(tag_params)
+      render 'tags/show', locals: {tag: tag}
+    end
+
+    def destroy
+      tag = ActsAsTaggableOn::Tag.find(params[:id])
+      tag.destroy
+      render 'tags/show', locals: {tag: tag}
+    end
+
+    private
+      def tag_params
+        params.require(:tag).permit(:name, :taggings_count)
+      end
+  end
+end

data/app/controllers/answers/application_controller.rb

@@ -0,0 +1,27 @@
+module Answers
+  class ApplicationController < ActionController::Base
+
+    protect_from_forgery with: :null_session
+
+    ensure_security_headers(
+      :hsts => {:max_age => 631138519, :include_subdomains => false},
+      :x_frame_options  => {:value => 'SAMEORIGIN'},
+      :x_xss_protection => {:value => 1, :mode => 'block'},
+      :x_content_type_options => {:value => 'nosniff'},
+      :csp => false
+    )
+
+    def redirect_to_back(default = root_url)
+      if !request.env["HTTP_REFERER"].blank? and request.env["HTTP_REFERER"] != request.env["REQUEST_URI"]
+        redirect_to :back
+      else
+        redirect_to default
+      end
+    end
+
+    def after_sign_in_path_for(resource_or_scope)
+      path = stored_location_for(resource_or_scope) || signed_in_root_path(resource_or_scope)
+      "/#{path}" if path[0] != "/" # hackity hack
+    end
+  end
+end

data/app/controllers/answers/home_controller.rb

@@ -0,0 +1,17 @@
+module Answers
+	class HomeController < Answers::ApplicationController
+	 # caches_page :index
+	  add_breadcrumb "Home", :root_url
+
+	  def index
+	    render locals: { 
+	      tags_with_questions: Question.tags_with_questions
+	    }
+	  end
+
+	 def about
+	   add_breadcrumb "About"
+	 end
+
+	end
+end

data/app/controllers/answers/questions_controller.rb

@@ -0,0 +1,33 @@
+module Answers
+  class QuestionsController < Answers::ApplicationController
+  before_action :set_question, only: [:show]
+  respond_to :html
+
+  add_breadcrumb "Home", :answers_path
+
+  def index
+    add_breadcrumb "Answers", answers_path
+    
+    @questions = Question.all
+    respond_with(@questions)
+  end
+
+  def show
+    add_breadcrumb "Answers", answers_path
+    add_breadcrumb @question.text, answer_path(@question)
+
+    render locals: { question: @question, similar_questions: @question.similar(limit:3) }
+  end
+
+  private
+    def set_question
+      @question = Question.find(params[:id])
+    end
+
+    def question_params
+      #params[:question]
+      #params.require(:question).permit(:text, :in_language)
+      params[:question]
+    end
+  end
+end

data/app/controllers/answers/search_controller.rb

@@ -0,0 +1,22 @@
+module Answers
+  class SearchController < Answers::ApplicationController
+    def index
+      query =  params[:q].strip
+      return redirect_to answers_path if params[:q].blank?
+      
+      results = Question.search(query, index_name: [Question.searchkick_index.name, Answer.searchkick_index.name])
+      
+      Rails.logger.info "search-request: IP:#{request.env['REMOTE_ADDR']}, params[:query]:#{query}, QUERY:#{query}, FIRST_RESULT:#{results.first.text unless results.empty?}, RESULTS_N:#{results.size}"
+
+      respond_to do |format|
+        format.json { render json: results }
+        format.html do 
+          render locals: {
+            results: results, 
+            query: query
+          } 
+        end
+      end
+    end
+  end
+end

data/app/controllers/answers/tags_controller.rb

@@ -0,0 +1,36 @@
+module Answers
+  class TagsController < Answers::ApplicationController
+    # caches_page :index
+    # caches_page :show 
+    
+    add_breadcrumb "Home", :answers_path
+    
+    def index
+      add_breadcrumb "Tags", answers.tags_path
+      
+      tags = ActsAsTaggableOn::Tag.all
+      render locals: {tags: tags}
+    end
+
+    def show
+      id  = params[:id].to_i
+      tag = ActsAsTaggableOn::Tag.find(id)
+      
+      add_breadcrumb "Tags", answers.tags_path
+      add_breadcrumb tag.name.capitalize, answers.tag_path(tag)
+      
+      taggings = tag.taggings.select do |tagging| 
+        tagging.taggable_type == "Question"
+      end
+      
+      questions = Question.find(
+                    taggings.map(&:taggable_id)
+                  )
+      
+      render locals: {
+        tag: tag,
+        questions: questions
+      }
+    end
+  end
+end

data/app/helpers/answers/tags_helper.rb

@@ -0,0 +1,7 @@
+module Answers
+	module TagsHelper
+	  def tag_path(tag)
+	    "/tags/#{tag.id}"
+	  end
+	end
+end

data/app/models/answers/ability.rb

@@ -0,0 +1,28 @@
+module Answers
+  class Ability
+    include CanCan::Ability
+
+    def initialize(user)
+
+      @q_and_a = [Question, Answer]
+
+      can :read, :all
+      can :manage, user
+
+      if user.is_admin
+        can :manage, :all
+      end
+
+      if user.is_editor
+        can :manage, @q_and_a
+      end
+
+      if user.is_writer
+        can :create, @q_and_a
+        # can [:update, :destroy], @q_and_a, status: "Draft", user_id: user.id
+        # can [:update, :destroy], @q_and_a, guide: { user_id: user.id, status: "Draft" }
+      end
+
+    end
+  end
+end

data/app/models/answers/administrator.rb

@@ -0,0 +1,5 @@
+module Answers
+	class Administrator < ActiveRecord::Base
+  	devise :database_authenticatable, :lockable, :timeoutable, :recoverable, :trackable
+	end
+end

data/app/models/answers/answer.rb

@@ -0,0 +1,6 @@
+module Answers
+	class Answer < ActiveRecord::Base
+	  belongs_to :question
+	  searchkick wordnet: true
+	end
+end

data/app/models/answers/api/v1/api_user.rb

@@ -0,0 +1,5 @@
+module Answers
+	class Api::V1::ApiUser < User
+  	acts_as_token_authenticatable
+	end
+end

data/app/models/answers/question.rb

@@ -0,0 +1,31 @@
+module Answers
+  class Question < ActiveRecord::Base
+
+    acts_as_taggable_on :tags
+    has_many :answers
+    searchkick wordnet: true
+
+    attr_writer :tag_ids
+    
+    def top_answer
+      self.answers.first
+    end
+    
+    # returns tags in order of most taggings to least taggings
+    def self.tags
+      self.tag_counts_on(:tags).sort_by(&:taggings_count).reverse
+    end
+    
+    def self.tags_with_questions
+      tags = self.tag_counts_on(:tags).limit(4).order("taggings_count DESC").all
+      tags_with_questions = tags.map do |tag|
+        {
+          tag: tag,
+          questions: Question.find(tag.taggings[0..3].map(&:taggable_id))
+        }
+      end
+      
+      tags_with_questions
+    end
+  end
+end