1
            

            

            ActiveAdmin.register AdminUser do
          
        
      
        

          

            1
            

            

              permit_params :email, :password, :password_confirmation
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              index do
          
        
      
        

          

            
            

            

                selectable_column
          
        
      
        

          

            
            

            

                id_column
          
        
      
        

          

            
            

            

                column :email
          
        
      
        

          

            
            

            

                column :current_sign_in_at
          
        
      
        

          

            
            

            

                column :sign_in_count
          
        
      
        

          

            
            

            

                column :created_at
          
        
      
        

          

            
            

            

                actions
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              filter :email
          
        
      
        

          

            1
            

            

              filter :current_sign_in_at
          
        
      
        

          

            1
            

            

              filter :sign_in_count
          
        
      
        

          

            1
            

            

              filter :created_at
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              form do |f|
          
        
      
        

          

            
            

            

                f.inputs do
          
        
      
        

          

            
            

            

                  f.input :email
          
        
      
        

          

            
            

            

                  f.input :password
          
        
      
        

          

            
            

            

                  f.input :password_confirmation
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                f.actions
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            ActiveAdmin.register City do
          
        
      
        

          

            
            

            

            # See permitted parameters documentation:
          
        
      
        

          

            
            

            

            # https://github.com/activeadmin/activeadmin/blob/master/docs/2-resource-customization.md#setting-up-strong-parameters
          
        
      
        

          

            
            

            

            #
          
        
      
        

          

            
            

            

            # permit_params :list, :of, :attributes, :on, :model
          
        
      
        

          

            
            

            

            #
          
        
      
        

          

            
            

            

            # or
          
        
      
        

          

            
            

            

            #
          
        
      
        

          

            
            

            

            # permit_params do
          
        
      
        

          

            
            

            

            #   permitted = [:permitted, :attributes]
          
        
      
        

          

            
            

            

            #   permitted << :other if params[:action] == 'create' && current_user.admin?
          
        
      
        

          

            
            

            

            #   permitted
          
        
      
        

          

            
            

            

            # end
          
        
      
        

          

            1
            

            

                permit_params :name, :lat, :long, :country, :state
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                form do |f|
          
        
      
        

          

            
            

            

                    inputs do
          
        
      
        

          

            
            

            

                        input :name
          
        
      
        

          

            
            

            

                        input :lat, :as => :number
          
        
      
        

          

            
            

            

                        input :long, :as => :number
          
        
      
        

          

            
            

            

                        input :country, :as => :string
          
        
      
        

          

            
            

            

                        input :state
          
        
      
        

          

            
            

            

                        actions
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            ActiveAdmin.register_page "Dashboard" do
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              menu priority: 1, label: proc{ I18n.t("active_admin.dashboard") }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              content title: proc{ I18n.t("active_admin.dashboard") } do
          
        
      
        

          

            
            

            

                div class: "blank_slate_container", id: "dashboard_default_message" do
          
        
      
        

          

            
            

            

                  span class: "blank_slate" do
          
        
      
        

          

            
            

            

                    span I18n.t("active_admin.dashboard_welcome.welcome")
          
        
      
        

          

            
            

            

                    small I18n.t("active_admin.dashboard_welcome.call_to_action")
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Here is an example of a simple dashboard with columns and panels.
          
        
      
        

          

            
            

            

                #
          
        
      
        

          

            
            

            

                # columns do
          
        
      
        

          

            
            

            

                #   column do
          
        
      
        

          

            
            

            

                #     panel "Recent Posts" do
          
        
      
        

          

            
            

            

                #       ul do
          
        
      
        

          

            
            

            

                #         Post.recent(5).map do |post|
          
        
      
        

          

            
            

            

                #           li link_to(post.title, admin_post_path(post))
          
        
      
        

          

            
            

            

                #         end
          
        
      
        

          

            
            

            

                #       end
          
        
      
        

          

            
            

            

                #     end
          
        
      
        

          

            
            

            

                #   end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                #   column do
          
        
      
        

          

            
            

            

                #     panel "Info" do
          
        
      
        

          

            
            

            

                #       para "Welcome to ActiveAdmin."
          
        
      
        

          

            
            

            

                #     end
          
        
      
        

          

            
            

            

                #   end
          
        
      
        

          

            
            

            

                # end
          
        
      
        

          

            
            

            

              end # content
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            ActiveAdmin.register StackJob do
          
        
      
        

          

            
            

            

            # See permitted parameters documentation:
          
        
      
        

          

            
            

            

            # https://github.com/activeadmin/activeadmin/blob/master/docs/2-resource-customization.md#setting-up-strong-parameters
          
        
      
        

          

            
            

            

            #
          
        
      
        

          

            
            

            

            # permit_params :list, :of, :attributes, :on, :model
          
        
      
        

          

            
            

            

            #
          
        
      
        

          

            
            

            

            # or
          
        
      
        

          

            
            

            

            #
          
        
      
        

          

            
            

            

            # permit_params do
          
        
      
        

          

            
            

            

            #   permitted = [:permitted, :attributes]
          
        
      
        

          

            
            

            

            #   permitted << :other if params[:action] == 'create' && current_user.admin?
          
        
      
        

          

            
            

            

            #   permitted
          
        
      
        

          

            
            

            

            # end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              permit_params :updated_at
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              index do
          
        
      
        

          

            
            

            

                selectable_column
          
        
      
        

          

            
            

            

                column :id
          
        
      
        

          

            
            

            

                column :md5hash
          
        
      
        

          

            
            

            

                column :url
          
        
      
        

          

            
            

            

                column :created_at
          
        
      
        

          

            
            

            

                column :updated_at
          
        
      
        

          

            
            

            

                actions
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class StackJobsController < ApplicationController
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              require 'open-uri'
          
        
      
        

          

            1
            

            

              require 'digest'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def index
          
        
      
        

          

            1
            

            

                @search_term = params[:search] || '[ruby-on-rails]'
          
        
      
        

          

            1
            

            

                @min_experience = params[:min] || ''
          
        
      
        

          

            1
            

            

                @max_experience = params[:max] || ''
          
        
      
        

          

            1
            

            

                @job_type = params[:type] || ''
          
        
      
        

          

            1
            

            

                @remote = params[:remote] || nil
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                args = {
          
        
      
        

          

            1
            

            

                  :search =>  @search_term,
          
        
      
        

          

            
            

            

                  :min_experience => @min_experience,
          
        
      
        

          

            
            

            

                  :max_experience => @max_experience,
          
        
      
        

          

            
            

            

                  :job_type => @job_type,
          
        
      
        

          

            
            

            

                  :remote => @remote
          
        
      
        

          

            
            

            

                }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                url = stack_jobs_url(args)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                @stack_jobs = get_stack_jobs(url)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def search
          
        
      
        

          

            
            

            

                args = {
          
        
      
        

          

            2
            

            

                  :search =>  params[:search] || '[ruby-on-rails]',
          
        
      
        

          

            
            

            

                  :min_experience => params[:min] || '',
          
        
      
        

          

            
            

            

                  :max_experience => params[:max] || '',
          
        
      
        

          

            
            

            

                  :job_type => params[:type] || '',
          
        
      
        

          

            
            

            

                  :remote => params[:remote] || nil
          
        
      
        

          

            
            

            

                }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                url = stack_jobs_url(args)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                begin
          
        
      
        

          

            2
            

            

                  @stack_jobs = get_stack_jobs(url)
          
        
      
        

          

            2
            

            

                  if (@stack_jobs.geo_json.blank?)
          
        
      
        

          

            1
            

            

                    render json: {"type": "Error", "message": "No jobs found. Try another search"}
          
        
      
        

          

            
            

            

                  else
          
        
      
        

          

            1
            

            

                    render json: @stack_jobs.geo_json
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                rescue NoMethodError
          
        
      
        

          

            
            

            

                  render json: {"type": "Error", "message": "No jobs found. Try another search"}
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              private
          
        
      
        

          

            1
            

            

                def get_stack_jobs(url)
          
        
      
        

          

            3
            

            

                  url_md5 = Digest::MD5.hexdigest url
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            3
            

            

                  @stack_jobs = StackJob.find_by(md5hash: url_md5)
          
        
      
        

          

            3
            

            

                  if @stack_jobs.blank?
          
        
      
        

          

            1
            

            

                    xml = Nokogiri::XML(open(url))
          
        
      
        

          

            1
            

            

                    @stack_jobs = StackJob.create(
          
        
      
        

          

            
            

            

                      md5hash: url_md5,
          
        
      
        

          

            
            

            

                      xml: xml,
          
        
      
        

          

            
            

            

                      url: url
          
        
      
        

          

            
            

            

                    )
          
        
      
        

          

            1
            

            

                    @stack_jobs.geo_json = @stack_jobs.to_geojson
          
        
      
        

          

            1
            

            

                    @stack_jobs.save
          
        
      
        

          

            2
            

            

                  elsif @stack_jobs.updated_at < (Time.now - 60.minutes)
          
        
      
        

          

            
            

            

                    xml = Nokogiri::XML(open(url))
          
        
      
        

          

            
            

            

                    @stack_jobs.xml = xml
          
        
      
        

          

            
            

            

                    @stack_jobs.geo_json = @stack_jobs.to_geojson
          
        
      
        

          

            
            

            

                    @stack_jobs.save
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            3
            

            

                  @stack_jobs
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def stack_jobs_url(**args)
          
        
      
        

          

            
            

            

                  url = "https://stackoverflow.com/jobs/feed?"\
          
        
      
        

          

            3
            

            

                        "q=#{args[:search]}"\
          
        
      
        

          

            
            

            

                        "&ms=#{args[:min_experience]}"\
          
        
      
        

          

            
            

            

                        "&mxs=#{args[:max_experience]}"\
          
        
      
        

          

            
            

            

                        "&j=#{args[:job_type]}"\
          
        
      
        

          

            
            

            

                        "&l=United%20States&d=20&u=Miles" # Currently the application only supports US
          
        
      
        

          

            3
            

            

                  unless args[:remote].nil?
          
        
      
        

          

            
            

            

                    url << "&r=true"
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            3
            

            

                  url
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class StaticController < ApplicationController
          
        
      
        

          

            1
            

            

              def pages
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def index
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class ZzhealthController < ApplicationController
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def index
          
        
      
        

          

            
            

            

                data = {
          
        
      
        

          

            1
            

            

                  'status' => 200,
          
        
      
        

          

            
            

            

                  'message' => 'OK',
          
        
      
        

          

            
            

            

                  'data' => [],
          
        
      
        

          

            
            

            

                }
          
        
      
        

          

            1
            

            

                render :json => data
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class AdminUser < ApplicationRecord
          
        
      
        

          

            
            

            

              # Include default devise modules. Others available are:
          
        
      
        

          

            
            

            

              # :confirmable, :lockable, :timeoutable and :omniauthable
          
        
      
        

          

            1
            

            

              devise :database_authenticatable, 
          
        
      
        

          

            
            

            

                     :recoverable, :rememberable, :trackable, :validatable
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class City < ApplicationRecord
          
        
      
        

          

            1
            

            

              validates :name, uniqueness: { scope: :state,
          
        
      
        

          

            
            

            

                message: "One [City, State] pair" }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def self.find_coordinates(city, state)
          
        
      
        

          

            290
            

            

                City.where("lower(name) = ? and lower(state) = ?",city.downcase, state.downcase).first
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def self.split_city_state(location)
          
        
      
        

          

            150
            

            

                location.split(", ")
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class StackJob < ApplicationRecord
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def to_geojson
          
        
      
        

          

            2
            

            

                  hash = Hash.from_xml(self.xml)
          
        
      
        

          

            2
            

            

                  items = hash['rss']['channel']['item']
          
        
      
        

          

            2
            

            

                  json = Hash.new
          
        
      
        

          

            2
            

            

                  json["type"] = "FeatureCollection"
          
        
      
        

          

            2
            

            

                  features = Array.new
          
        
      
        

          

            2
            

            

                  items.each do | item |
          
        
      
        

          

            149
            

            

                      if item['location'].nil?
          
        
      
        

          

            
            

            

                        city_loc = City.find_coordinates("remote", "us")
          
        
      
        

          

            
            

            

                      else
          
        
      
        

          

            149
            

            

                        scs = City.split_city_state item["location"]
          
        
      
        

          

            149
            

            

                        city_loc = City.find_coordinates(scs[0],scs[1])
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            149
            

            

                      if city_loc.nil? then city_loc = City.find_coordinates("not found", "us") end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            149
            

            

                      date = DateTime.parse(item['pubDate'])
          
        
      
        

          

            149
            

            

                      dateFmt = date.strftime("%Y-%m-%dT%H:%M:%S")
          
        
      
        

          

            149
            

            

                      categories = item['category'].presence || ["none"]
          
        
      
        

          

            149
            

            

                      categories = ( categories.is_a?(Array) ) ? categories : Array(categories)
          
        
      
        

          

            149
            

            

                      title = item['title'].split(" at ")
          
        
      
        

          

            149
            

            

                      if title.last.include? "allows remote"
          
        
      
        

          

            35
            

            

                          title.first << " (allows remote)"
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            149
            

            

                      feature = { "type"           => "Feature",
          
        
      
        

          

            
            

            

                                  "properties"     => {
          
        
      
        

          

            
            

            

                                      "show_on_map"  => "true",
          
        
      
        

          

            
            

            

                                      "link"         => item['link'],
          
        
      
        

          

            
            

            

                                      "name"         => title.first,
          
        
      
        

          

            
            

            

                                      "company"      => item['author']['name'],
          
        
      
        

          

            
            

            

                                      "city"         => item['location'],
          
        
      
        

          

            
            

            

                                      "category"     => categories,
          
        
      
        

          

            
            

            

                                      "date"         => dateFmt
          
        
      
        

          

            
            

            

                                     },
          
        
      
        

          

            
            

            

                                  "geometry"       => {
          
        
      
        

          

            
            

            

                                      "type"         => "Point",
          
        
      
        

          

            
            

            

                                      "coordinates"  => [ city_loc.long, city_loc.lat ]
          
        
      
        

          

            
            

            

                                     }
          
        
      
        

          

            
            

            

                                }
          
        
      
        

          

            149
            

            

                      features.push( feature )
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            2
            

            

                  json["features"] = features
          
        
      
        

          

            2
            

            

                  json.to_json
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end