rails_adserver 1.0.0

data/app/assets/stylesheets/rails_adserver/pages.css

@@ -0,0 +1,16 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/
+footer{
+  padding: 40px 0 0 0;
+	text-align:center;
+}
+
+legend{
+	font-size: 30px;
+}
+
+h1{
+	padding: 0 0 30px 0;
+}

data/app/controllers/rails_adserver/adspaces_controller.rb

@@ -0,0 +1,88 @@
+module RailsAdserver
+  class AdspacesController < RailsAdserver::ApplicationController
+    before_filter :_authenticate
+    # GET /adspaces
+    # GET /adspaces.json
+    def index
+      @title = "Ad-Spaces"
+      @adspaces = Adspace.all
+      respond_to do |format|
+        format.html # index.html.erb
+        format.json { render json: @adspaces }
+      end
+    end
+  
+    # GET /adspaces/1
+    # GET /adspaces/1.json
+    def show
+      @adspace = Adspace.find(params[:id])
+      @tile = "Ad-Space - #{@adspace.name}"
+      respond_to do |format|
+        format.html # show.html.erb
+        format.json { render json: @adspace }
+      end
+    end
+  
+    # GET /adspaces/new
+    # GET /adspaces/new.json
+    def new
+      @title = "New Ad-Space"
+      @adspace = Adspace.new
+      respond_to do |format|
+        format.html # new.html.erb
+        format.json { render json: @adspace }
+      end
+    end
+  
+    # GET /adspaces/1/edit
+    def edit
+      @title = "Edit Ad-Space"
+      @adspace = Adspace.find(params[:id])
+    end
+  
+    # POST /adspaces
+    # POST /adspaces.json
+    def create
+      @title = "New Ad-Space"
+      @adspace = Adspace.new(params[:adspace])
+      respond_to do |format|
+        if @adspace.save
+          format.html { redirect_to  adspaces_url, notice: 'Adspace was successfully created.' }
+          format.json { render json: @adspace, status: :created, location: @adspace }
+        else
+          format.html { render action: "new" }
+          format.json { render json: @adspace.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  
+    # PUT /adspaces/1
+    # PUT /adspaces/1.json
+    def update
+      @title = "Edit Ad-Space"
+      @adspace = Adspace.find(params[:id])
+      respond_to do |format|
+        if @adspace.update_attributes(params[:adspace])
+          format.html { redirect_to @adspace, notice: 'Adspace was successfully updated.' }
+          format.json { head :no_content }
+        else
+          format.html { render action: "edit" }
+          format.json { render json: @adspace.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  
+    # DELETE /adspaces/1
+    # DELETE /adspaces/1.json
+    def destroy
+      @adspace = Adspace.find(params[:id])
+      @adspace.destroy
+  
+      respond_to do |format|
+        format.html { redirect_to adspaces_url }
+        format.json { head :no_content }
+      end
+    end
+    
+  end
+end

data/app/controllers/rails_adserver/advertisements_controller.rb

@@ -0,0 +1,113 @@
+module RailsAdserver
+  class AdvertisementsController < RailsAdserver::ApplicationController
+    before_filter :_authenticate, :except => [:ad_param, :ad_space]
+    require 'carrierwave'
+    def ad_param
+      id = RailsAdserver::Advertisement.ad_with_parameter(params[:adspace_id],params[:id],request.remote_ip)
+      @advertisement = RailsAdserver::Advertisement.find(id)
+      respond_to do |format|
+        format.html {render :partial => 'advertisement', :layout => false}
+      end
+    end
+    
+    def ad_space
+      id = RailsAdserver::Advertisement.ad(params[:adspace_id],request.remote_ip)
+      @advertisement = RailsAdserver::Advertisement.find(id)
+      respond_to do |format|
+        format.html {render :partial => 'advertisement', :layout => false}
+      end
+    end
+     
+    def click
+      client_ip = request.remote_ip
+      ad = Advertisement.find(params[:id])
+      ad.clicks.create(:ip_address => client_ip)
+      ad.update_attribute(:click_count,ad.clicks.count)
+      if ad.click_count >= ad.max_clicks
+        unless ad.max_clicks == 0
+          ad.update_attribute(:is_active,false)
+        end
+      end
+      redirect_to ad.url
+    end
+    # GET /advertisements
+    def index
+      @advertisements = Advertisement.all
+      @title = "Advertisements"
+      respond_to do |format|
+        format.html # index.html.erb
+        format.json { render json: @advertisements }
+      end
+    end
+  
+    # GET /advertisements/1
+    def show
+      @advertisement = Advertisement.find(params[:id])
+      @title = @advertisement.title
+      respond_to do |format|
+        format.html # show.html.erb
+        format.json { render json: @advertisement }
+      end
+    end
+  
+    # GET /advertisements/new
+    def new
+      @advertisement = Advertisement.new
+      @title = "New Advertisement"
+      respond_to do |format|
+        format.html # new.html.erb
+        format.json { render json: @advertisement }
+      end
+    end
+  
+    # GET /advertisements/1/edit
+    def edit
+      @title = "Edit Advertisement"
+      @advertisement = Advertisement.find(params[:id])
+    end
+  
+    # POST /advertisements
+    def create
+      @advertisement = Advertisement.new(params[:advertisement])
+      geo = Geokit::Geocoders::MultiGeocoder.geocode(@advertisement.geolocation_location)
+      @advertisement.update_attributes(:city_name => geo.city, :state_name => geo.state, :country_name => geo.country)
+      respond_to do |format|
+        if @advertisement.save
+          format.html { redirect_to @advertisement, notice: 'Advertisement was successfully created.' }
+          format.json { render json: @advertisement, status: :created, location: @advertisement }
+        else
+          format.html { render action: "new" }
+          format.json { render json: @advertisement.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  
+    # PUT /advertisements/1
+    def update
+      @advertisement = Advertisement.find(params[:id])
+      respond_to do |format|
+        if @advertisement.update_attributes(params[:advertisement])
+          geo = Geokit::Geocoders::MultiGeocoder.geocode(@advertisement.geolocation_location)
+          @advertisement.update_attributes(:city_name => geo.city, :state_name => geo.state, :country_name => geo.country)
+          format.html { redirect_to @advertisement, notice: 'Advertisement was successfully updated.' }
+          format.json { head :no_content }
+        else
+          format.html { render action: "edit" }
+          format.json { render json: @advertisement.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+  
+    # DELETE /advertisements/1
+    def destroy
+      @advertisement = Advertisement.find(params[:id])
+      @advertisement.destroy
+  
+      respond_to do |format|
+        format.html { redirect_to advertisements_url }
+        format.json { head :no_content }
+      end
+    end
+    
+  end
+end

data/app/controllers/rails_adserver/application_controller.rb

@@ -0,0 +1,25 @@
+module RailsAdserver
+  class ApplicationController < ActionController::Base
+    helper :all
+    helper_method :_current_user, :_application_name, :_model_pool
+    private
+    def _model_pool
+      RailsAdserver::Config.models_pool
+    end
+    def _application_name
+      RailsAdserver::Config.application_name
+    end
+    def _current_user
+      instance_eval &RailsAdserver::Config.current_user_method
+    end
+    def _authenticate
+      if _current_user == nil
+        redirect_to '/404.html'
+      else
+        unless _current_user.can_manage_ads
+          redirect_to '/404.html'
+        end
+      end
+    end
+  end
+end

data/app/controllers/rails_adserver/pages_controller.rb

@@ -0,0 +1,9 @@
+module RailsAdserver
+  class PagesController < RailsAdserver::ApplicationController
+    before_filter :_authenticate
+    def home
+      @title = "Overview"
+      @adspaces = RailsAdserver::Adspace.find(:all)
+    end
+  end
+end

data/app/helpers/rails_adserver/adspaces_helper.rb

@@ -0,0 +1,4 @@
+module RailsAdserver
+  module AdspacesHelper
+  end
+end

data/app/helpers/rails_adserver/advertisements_helper.rb

@@ -0,0 +1,4 @@
+module RailsAdserver
+  module AdvertisementsHelper
+  end
+end

data/app/helpers/rails_adserver/application_helper.rb

@@ -0,0 +1,4 @@
+module RailsAdserver
+  module ApplicationHelper
+  end
+end

data/app/helpers/rails_adserver/pages_helper.rb

@@ -0,0 +1,5 @@
+module RailsAdserver
+  module PagesHelper
+    
+  end
+end

data/app/models/rails_adserver/adspace.rb

@@ -0,0 +1,6 @@
+module RailsAdserver
+  class Adspace < ActiveRecord::Base
+    has_many :advertisements
+    validates :name, :presence => true
+  end
+end

data/app/models/rails_adserver/advertisement.rb

@@ -0,0 +1,110 @@
+module RailsAdserver
+  class Advertisement < ActiveRecord::Base
+    belongs_to :adspace
+    has_many :clicks
+    require 'carrierwave/orm/activerecord'
+    
+    attr_accessible :image, :title, :content, :width, :height, :is_active, :param_restriction, :ad_text, :parameter_restriction_boolean,
+    :param_restriction_name, :adspace_id, :ad_type, :url, :geolocation_boolean, :max_clicks, :geolocation_location, :city_name, :state_name, :country_name, :backup,
+    :max_impressions
+    
+    validates :title, :presence => true
+    validates :adspace_id, :presence => true
+    
+    mount_uploader :image, AdvertisementUploader
+    
+    def self.ad_with_parameter(adspace_id,param,ip)
+      space = RailsAdserver::Adspace.find(adspace_id)
+      id = space.advertisements.random_ad(param)
+      if id == nil
+        geo_ip = Geokit::Geocoders::MultiGeocoder.geocode(ip)
+        geo =  Geokit::Geocoders::MultiGeocoder.geocode("#{geo_ip.city},#{geo_ip.state},#{geo_ip.country}")
+        id =  space.advertisements.geo_city(geo.city)
+        if id == nil
+          id = space.advertisements.geo_state(geo.state)
+          if id == nil
+            id = space.advertisements.geo_country(geo.country)
+            if id == nil
+              id = space.advertisements.random_ad(nil)
+              if id == nil
+                id = space.advertisements.backup_ad
+              end
+            end
+          end
+        end
+      end
+      unless id == nil
+        advertisement = RailsAdserver::Advertisement.find(id)
+        if advertisement.impressions_count == nil
+          advertisement.update_attribute(:impressions_count,0)
+        end
+        count = advertisement.impressions_count+1
+        advertisement.update_attribute(:impressions_count,count)
+        unless advertisement.max_impressions == 0 || advertisement.max_impressions == nil
+          if advertisement.max_impressions <= advertisement.impressions_count
+            advertisement.update_attribute(:is_active,false)
+          end
+        end
+      end
+      return id
+    end
+    
+    def self.ad(adspace_id,ip)
+      space = RailsAdserver::Adspace.find(adspace_id)
+      geo_ip = Geokit::Geocoders::MultiGeocoder.geocode(ip)
+      geo =  Geokit::Geocoders::MultiGeocoder.geocode("#{geo_ip.city},#{geo_ip.state},#{geo_ip.country}")
+      id =  space.advertisements.geo_city(geo.city)
+      if id == nil
+        id = space.advertisements.geo_state(geo.state)
+        if id == nil
+          id = space.advertisements.geo_country(geo.country)
+          if id == nil
+            id = space.advertisements.random_ad(nil)
+            if id == nil
+              id = space.advertisements.backup_ad
+            end
+          end
+        end
+      end
+      unless id == nil
+        advertisement = RailsAdserver::Advertisement.find(id)
+        if advertisement.impressions_count == nil
+          advertisement.update_attribute(:impressions_count,0)
+        end
+        count = advertisement.impressions_count+1
+        advertisement.update_attribute(:impressions_count,count)
+        unless advertisement.max_impressions == 0 || advertisement.max_impressions == nil
+          if advertisement.max_impressions <= advertisement.impressions_count
+            advertisement.update_attribute(:is_active,false)
+          end
+        end
+      end
+      return id
+    end
+    
+    def self.random_ad(param)
+      if param == nil
+        ad_ids = self.where("is_active = ? AND parameter_restriction_boolean = ? AND geolocation_boolean = ? AND backup = ?", true, false, false, false).map(&:id)
+      else
+        ad_ids = self.where("is_active = ? AND param_restriction = ? AND backup = ?",true, param, false).map(&:id)
+      end
+      id = ad_ids[rand(ad_ids.length)]
+    end
+    def self.geo_city(city)
+      ad_ids = self.where("city_name = ? AND is_active = ?", city, true).map(&:id)
+      id = ad_ids[rand(ad_ids.length)]
+    end
+    def self.geo_state(state)
+      ad_ids = self.where("state_name = ? AND city_name = ? AND is_active = ?", state, nil,  true).map(&:id)
+      id = ad_ids[rand(ad_ids.length)]
+    end
+    def self.geo_country(country)
+      ad_ids = self.where("country_name = ? AND state_name = ? AND city_name = ? AND is_active = ?", country, nil, nil, true).map(&:id)
+      id = ad_ids[rand(ad_ids.length)]
+    end
+    def self.backup_ad
+      ad_ids = self.where("backup = ?", true).map(&:id)
+      id = ad_ids[rand(ad_ids.length)]
+    end
+  end
+end

data/app/models/rails_adserver/click.rb

@@ -0,0 +1,5 @@
+module RailsAdserver
+  class Click < ActiveRecord::Base
+    belongs_to :advertisement
+  end
+end

data/app/uploaders/rails_adserver/advertisement_uploader.rb

@@ -0,0 +1,56 @@
+module RailsAdserver
+  class AdvertisementUploader < CarrierWave::Uploader::Base
+    
+    # Include RMagick or MiniMagick support:
+    # include CarrierWave::RMagick
+    # include CarrierWave::MiniMagick
+
+    # Choose what kind of storage to use for this uploader:
+    if RailsAdserver::Config.carrierwave_method == "Fog"
+      storage :fog
+    else
+      storage :file
+    end
+
+    # Override the directory where uploaded files will be stored.
+    # This is a sensible default for uploaders that are meant to be mounted:
+    def store_dir
+      "public/uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+    end
+    def extension_white_list
+      %w(jpg jpeg gif png)
+    end
+    
+    def cache_dir
+      "#{Rails.root}/tmp/uploads"
+    end
+    # Provide a default URL as a default if there hasn't been a file uploaded:
+    # def default_url
+    #   "/images/fallback/" + [version_name, "default.png"].compact.join('_')
+    # end
+
+    # Process files as they are uploaded:
+    # process :scale => [200, 300]
+    #
+    # def scale(width, height)
+    #   # do something
+    # end
+
+    # Create different versions of your uploaded files:
+    # version :thumb do
+    #   process :scale => [50, 50]
+    # end
+
+    # Add a white list of extensions which are allowed to be uploaded.
+    # For images you might use something like this:
+    # def extension_white_list
+    #   %w(jpg jpeg gif png)
+    # end
+
+    # Override the filename of the uploaded files:
+    # Avoid using model.id or version_name here, see uploader/store.rb for details.
+    # def filename
+    #   "something.jpg" if original_filename
+    # end
+  end
+end