ActionView::Base.field_error_proc = Proc.new{ |html_tag, instance| "#{html_tag}".html_safe }
# render invalid request to show error message depend on request type
# example:
# render_invalid "Update failed."
# ajax: show error notification with message "Update failed."
# html: simply render text "Update failed."
# render_invalid "Save failed.", :render => {:action => "new"}
# ajax: show error notification with message "Save failed."
# html: render action new with "Save failed." flash message
# render_invalid "Save failed.", :render => {:action => "new"}, :flash => false
# same as above but without flash for html
# render_invalid "You can't do that.", :redirect_to => {:action => "index"}, :flash => false, :status => :unauthorized
# same as above but redirecting to index instead of rendering new for html
# and using unauthorized(401) status instead of not_acceptable(406)
# render_invalid "Update failed.", :object => @user, :fields_wrapping => true
# ajax: show error notification with addition of object's error messages and wrap error fields with div class fieldWithErrors
# html: same as ajax minus fields wrapping
def render_invalid message="Error.", options={:flash => true}
options[:status] ||= :not_acceptable
message += "#{options[:object].errors.full_messages.join('
')}" if options[:object].present?
respond_to do |format|
format.js do
render(:update, :status => options[:status]) do |page|
page << notification_error(message)
if options[:object].present? && options[:fields_wrapping]
page.rjs_clean_error_fields request
page.rjs_apply_error_fields options[:object], request
end
end
end
format.html do
if options[:render].present?
flash.now[:error] = message if options[:flash]
render options[:render].try(:merge, {:status => options[:status]}) || {:text => message, :status => options[:status]}
elsif options[:redirect_to].present?
flash[:error] = message if options[:flash]
redirect_to options[:redirect_to]
else
render :text => message, :status => options[:status]
end
end
end
end
def rjs_apply_error_fields object, request
klass_name = object.class.name.underscore
wrapper = ""
object.errors.each do |attr, msg|
attr = attr.split(".")
page << "var $fields = $(), $container = $('\##{klass_name}_#{object.id || "new"}');"
page << "if(!$container.length) $container = $('form[action=\\'#{request.request_uri}\\']');"
page << "if(!$container.length) $container = $(document);"
if attr.length > 1
object.send(attr.first).each_with_index do |x,i|
page << "$fields = $fields.add('[id^=#{klass_name}_#{attr.first}_attributes][id$=#{attr.last}]:eq(#{i}),label[for^=#{klass_name}_#{attr.first}_attributes][for$=#{attr.last}]:eq(#{i})', $container)" if x.errors.on(attr.last)
end
else
page << "$fields = $('label[for=#{klass_name}_#{attr}],\##{klass_name}_#{attr}', $container);"
end
page << "if(!$fields.parent('.fieldWithErrors').length)"
page << "$fields.wrap('#{wrapper}')"
end
end
def rjs_clean_error_fields request
page << "$('.fieldWithErrors.rjs_#{request.request_method}_#{request.request_uri.gsub(/_=\d+($|&)/, "").parameterize} *').unwrap();"
end
#...
def create
@user = User.new(params[:user])
unless @user.save
render_invalid "Failed to register.", :object => @user, :render => {:action => "new"}
else
flash[:info] = "Registration success, please check your email to activate."
redirect_to login_path
end
end
#...
users_controller.rb (using ajax form)
#...
def update
@user = current_user
unless @user.update_attributes(params[:user])
render_invalid "Profile update failed.", :object => @user, :fields_wrapping => true
end
end
#...
and update.js.rjs (for success behavior)
page << notification_info "Profile updated." page.rjs_clean_error_fields request # used for cleaning error fields wrapping #... other necessary action ...
console.log(0.1+0.2); //-> 0.30000000000000004 console.log(0.1*0.2); //-> 0.020000000000000004
# Adding additional options for ajax function
# You can use thisElement to manipulate element that using the function (link/button/form)
def custom_remote_function_options options
options[:before] ||= ""
options[:loading] ||= ""
options[:complete] ||= ""
options[:success] ||= ""
options[:before] += "; var thisElement=this"
options[:failure] ||= "; eval(request.responseText)"
unless options[:loading_text].blank?
options[:loading] += "; thisElement.notif = #{notification_loading(options[:loading_text])}"
options[:complete] += "; #{notification_remove "thisElement.notif"}"
end
options
end
# Override rails remote_function using additional options
def custom_remote_function options
remote_function(custom_remote_function_options(options)).html_safe
end
# Override rails link_to_remote function using additional options
# Disabling the link when ajax loading in progress to avoid double request
def custom_link_to_remote name, options={}, html_options=nil
options = custom_remote_function_options options
options[:loading] += "; $(thisElement).setLink(false)"
options[:complete] += "; $(thisElement).setLink(true)"
link_to_remote name, options, html_options
end
# Override rails button_to_remote function using additional options
# Disabling the button when ajax loading in progress to avoid double request
def custom_button_to_remote name, options={}, html_options=nil
options = custom_remote_function_options options
options[:loading] += "; $(thisElement).setInput(false)"
options[:complete] += "; $(thisElement).setInput(true)"
button_to_remote name, options, html_options
end
# Adding additional options for ajax form
# Add :unchange_default => true to prevent successful request changing default form fields value
# Add :disable_link => true to disable all link inside form when loading in progress
def custom_remote_form_options options
options = custom_remote_function_options options
options[:loading] += "; $(':input', thisElement).setInput(false);"
options[:complete] += "; $(':input', thisElement).setInput(true);"
unless options[:unchange_default]
options[:success] += "; $(':input', thisElement).setDefault();"
end
if options[:disable_link]
options[:loading] += "; $('a', thisElement).setLink(false);"
options[:complete] += "; $('a', thisElement).setLink(true);"
end
options
end
# Override rails remote_form_for using additional options
def custom_remote_form_for record_or_name_or_array, *args, &proc
args.push custom_remote_form_options(args.extract_options!)
remote_form_for record_or_name_or_array, *args, &proc
end
alias_method :custom_form_remote_for, :custom_remote_form_for
# Override rails form_remote_tag using additional options
def custom_form_remote_tag options={}, &block
form_remote_tag custom_remote_form_options(options), &block
end
alias_method :custom_remote_form_tag, :custom_form_remote_tag
def custom_button_to_remote name, value, options = {}
button_to_remote name, value, custom_remote_form_options(options)
end
# Override rails submit_to_remote using additional options
def custom_submit_to_remote(name, value, options = {})
submit_to_remote(name, value, custom_remote_form_options(options))
end
def notification_info text, no_escape=false
text.gsub!(/\n/, '
')
text = escape_javascript(text) unless no_escape
"notificationInfo('#{text}')"
end
def notification_loading text, no_escape=false
text.gsub!(/\n/, '
')
text = escape_javascript(text) unless no_escape
"notificationLoading('#{text}')"
end
def notification_error text, no_escape=false
text.gsub!(/\n/, '
')
text = escape_javascript(text) unless no_escape
"notificationError('#{text}')"
end
def notification_remove notification
"notificationRemove(#{notification})"
end
function notificationInfo(text){
return $.gritter.add({text: text.replace(/\n/g, '
')});
}
function notificationError(text){
return $.gritter.add({text: '' + text.replace(/\n/g, '
') + '',time: 6000});
}
function notificationLoading(text){
return $.gritter.add({text: text.replace(/\n/g, '
'), image: '/images/gritter-loading.gif', sticky:true})
}
function notificationRemove(notification){
$.gritter.remove(notification);
}
| Status Code | Status Message | Symbol |
|---|---|---|
| 1xx Informational | ||
| 100 | Continue | :continue |
| 101 | Switching Protocols | :switching_protocols |
| 102 | Processing | :processing |
| 2xx Success | ||
| 200 | OK | :ok |
| 201 | Created | :created |
| 202 | Accepted | :accepted |
| 203 | Non-Authoritative Information | :non_authoritative_information |
| 204 | No Content | :no_content |
| 205 | Reset Content | :reset_content |
| 206 | Partial Content | :partial_content |
| 207 | Multi-Status | :multi_status |
| 226 | IM Used | :im_used |
| 3xx Redirection | ||
| 300 | Multiple Choices | :multiple_choices |
| 301 | Moved Permanently | :moved_permanently |
| 302 | Found | :found |
| 303 | See Other | :see_other |
| 304 | Not Modified | :not_modified |
| 305 | Use Proxy | :use_proxy |
| 307 | Temporary Redirect | :temporary_redirect |
| 4xx Client Error | ||
| 400 | Bad Request | :bad_request |
| 401 | Unauthorized | :unauthorized |
| 402 | Payment Required | :payment_required |
| 403 | Forbidden | :forbidden |
| 404 | Not Found | :not_found |
| 405 | Method Not Allowed | :method_not_allowed |
| 406 | Not Acceptable | :not_acceptable |
| 407 | Proxy Authentication Required | :proxy_authentication_required |
| 408 | Request Timeout | :request_timeout |
| 409 | Conflict | :conflict |
| 410 | Gone | :gone |
| 411 | Length Required | :length_required |
| 412 | Precondition Failed | :precondition_failed |
| 413 | Request Entity Too Large | :request_entity_too_large |
| 414 | Request-URI Too Long | :request_uri_too_long |
| 415 | Unsupported Media Type | :unsupported_media_type |
| 416 | Requested Range Not Satisfiable | :requested_range_not_satisfiable |
| 417 | Expectation Failed | :expectation_failed |
| 422 | Unprocessable Entity | :unprocessable_entity |
| 423 | Locked | :locked |
| 424 | Failed Dependency | :failed_dependency |
| 426 | Upgrade Required | :upgrade_required |
| 5xx Server Error | ||
| 500 | Internal Server Error | :internal_server_error |
| 501 | Not Implemented | :not_implemented |
| 502 | Bad Gateway | :bad_gateway |
| 503 | Service Unavailable | :service_unavailable |
| 504 | Gateway Timeout | :gateway_timeout |
| 505 | HTTP Version Not Supported | :http_version_not_supported |
| 507 | Insufficient Storage | :insufficient_storage |
| 510 | Not Extended | :not_extended |
# system_settings/lib/system_setting.rb
class SystemSetting < ActiveRecord::Base
@@data = {}
validates_length_of :name, :in => 1..255
validates_uniqueness_of :name
serialize :value
def self.[](name)
name = name.to_s unless name.is_a? String
return @@data[name] unless @@data[name].nil?
p = SystemSetting.find_by_name(name)
@@data[name] = p ? p.value.freeze : nil
end
def self.[]=(name, value)
name = name.to_s unless name.is_a? String
p = SystemSetting.find_or_initialize_by_name(name)
@@data[name] = p.value = value
p.save!
p.value.freeze
end
end
t.column :unsigned_value, "integer unsigned"
t.integer :unsigned_value, :unsigned => true
| :limit | Numeric Type | Column Size | Signed Max value | Unsigned Max value |
|---|---|---|---|---|
| 1 | TINYINT(4) | 1 byte | 127 | 255 |
| 2 | SMALLINT(6) | 2 bytes | 32767 | 65535 |
| 3 | MEDIUMINT(9) | 3 bytes | 8388607 | 16777215 |
| 4 and others | INT(11) | 4 bytes | 2147483647 | 4294967295 |
| 5..8 | BIGINT(20) | 8 bytes | 9223372036854775807 | 18446744073709551615 |
include ExceptionLoggable rescue_from Exception, :with => :exception_handler private def exception_handler exception log_exception exception render "/500.html" end
r = Range.find_all(:conditions => ["NOT ((end < ?) || (start > ?))", new_start, new_end]) overlap = r.present? number_of_overlaps = r.length
$.extend(hash1, hash2);
$.extend(true, hash1, hash2);
# reset:
ActionView::Helpers::AssetTagHelper::JAVASCRIPT_DEFAULT_SOURCES = [
'jquery-1.4.3', 'jquery-ui-1.8.6.custom', 'jrails',
'jquery.extended_helper_2.0', 'date-id', 'jquery.gritter'
]
ActionView::Helpers::AssetTagHelper::reset_javascript_include_default
# adding:
ActionView::Helpers::AssetTagHelper::register_javascript_include_default 'extended_helper', 'date'
module I18n
module Backend
module Base
def translate(locale, key, options = {})
raise InvalidLocale.new(locale) unless locale
return key.map { |k| translate(locale, k, options) } if key.is_a?(Array)
entry = key && lookup(locale, key, options[:scope], options)
if options.empty?
entry = resolve(locale, key, entry, options)
else
count, default = options.values_at(:count, :default)
values = options.except(*RESERVED_KEYS)
entry = entry.nil? && default ?
default(locale, key, default, options) : resolve(locale, key, entry, options)
end
raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
entry = entry.dup if entry.is_a?(String)
entry = pluralize(locale, entry, count)
entry = interpolate(locale, entry, values) if values
entry
end
end
end
end
module I18n
module Backend
class Simple
def pluralize(locale, entry, count)
if !defined?(count) || count.blank?
key = :none
elsif count == 0 && (entry.respond_to?(:has_key?) && entry.has_key?(:zero))
key = :zero
end
key ||= count == 1 ? :one : :other
unless entry.respond_to?(:has_key?) && entry.has_key?(key)
entry
else
entry[key]
end
end
end
end
end
#--
# constants
#++
#--
# require
#++
#--
# include
#++
#--
# attr
#++
#--
# extra capabilities
#++
#--
# belongs_to
#++
#--
# has_one
#++
#--
# has_many
#++
#--
# accepts_nested_attributes_for
#++
#--
# validation
#++
#--
# callbacks
#++
#--
# named_scope
#++
#--
# other definition such as alias_method
#++
#--
# public class methods
#++
#--
# public instance methods
#++
private
#--
# private class methods
#++
#--
# private instance methods
#++
protected
#--
# protected class methods
#++
#--
# protected instance methods
#++
before_filter :prepare_account, :only => [:show, :edit, :update, :destroy]
# GET new_account_url
def new
# return an HTML form for describing the new account
end
# POST account_url
def create
# create an account
end
# GET account_url
def show
# find and return the account
end
# GET edit_account_url
def edit
# return an HTML form for editing the account
end
# PUT account_url
def update
# find and update the account
unless @account.update_attributes params[:account]
# failure code here..
end
end
# DELETE account_url
def destroy
# delete the account
@account.destroy
end
private
def prepare_account
@account = Account.first
end
before_filter :prepare_messages, :only => [:index]
before_filter :prepare_message, :only => [:show, :edit, :update, :destroy]
# GET messages_url
def index
# return all messages
end
# GET new_message_url
def new
# return an HTML form for describing a new message
end
# POST messages_url
def create
# create a new message
end
# GET message_url(:id => 1)
def show
# find and return a specific message
end
# GET edit_message_url(:id => 1)
def edit
# return an HTML form for editing a specific message
end
# PUT message_url(:id => 1)
def update
# find and update a specific message
unless @message.update_attributes params[:message]
# failure code here..
end
end
# DELETE message_url(:id => 1)
def destroy
# delete a specific message
@message.destroy
end
private
def prepare_messages
@messages = Message.all
end
def prepare_message
@message = Message.find params[:id]
end
validates_format_of :${1 default="attribute"}
validates_numericality_of :${1 default="attribute"}
127.0.1.1 localhost
127.0.1.2 mysite.local
127.0.1.3 www.mysite.local
127.0.1.5 user1.mysite.local
127.0.1.6 user2.mysite.local
...
function FindProxyForURL(url, host) {
if (shExpMatch(host, "*.local")) {
return "PROXY 127.0.0.1:3000";
}
if (shExpMatch(host, "*.example.com")){
return "PROXY 127.0.0.1:3000";
}
return "DIRECT";
}
/* return a copy of array with all null and optionally blank or false elements removed
* example:
* - arrayCompact(['a',null, 0, '', false]) //=> [ 'a', 0, '', false ] (only null removed)
* - arrayCompact(['a',null, 0, '', false], 1) //=> [ 'a', 0, false ] (only null and empty string removed)
* - arrayCompact(['a',null, 0, '', false], 2) //=> [ 'a' ] (all that equal to false removed)
*/
function arrayCompact(array, remove_level){
var new_array = new Array();
for(k in array)
if(typeof(array[k]) != 'undefined' &&
array[k] != null &&
!(remove_level > 0 &&
(typeof(array[k]) == 'string' || remove_level > 1) &&
array[k] == ''))
new_array.push(array[k]);
return new_array;
}
function debugInput(){
$('.debug_input').remove();
$(':input:not(textarea,:text:not(.date),:button,:submit,:reset)').each(function(){
$(this).after(''+this.name+':').css('border', 'medium dotted gray');
});
$('form').each(function(){
$(this).append(''+this.id+':')
});
$('.debug_input').css('opacity', 0.7).draggable();
}
ruby script/generate model Paypal
ruby script/generate model Ipn
### paypal.rb ###
belongs_to :payable, :polymorphic => true
has_many :ipns, :as => :gateway, :dependent => :destroy
### ipn.rb ###
belongs_to :gateway, :polymorphic => true
### user.rb ###
include PaymentGatewayRelation
### /lib/payment_gateway_relation.rb ###
module PaymentGatewayRelation
def self.included(recipient)
recipient.class_eval do
has_one :paypal, :as => :payable, :dependent => :destroy
def payments
[self.paypal].compact
end
def payment_available?
!self.payments.empty?
end
def payment
self.payments.first
end
def payment= value
return unless value.respond_to? :payable
klass = value.class
self.payments.each{|x| x.destroy if x.class != klass}
self.reload
self.send("#{klass.to_s.underscore}=", value)
end
end
end
end
class CreatePaypals < ActiveRecord::Migration
def self.up
create_table :paypals do |t|
t.references :payable, :polymorphic => true
t.string :business, :limit => 70
t.string :return_url
t.timestamps
end
end
def self.down
drop_table :paypals
end
end
class CreateIpns < ActiveRecord::Migration
def self.up
create_table :ipns do |t|
t.references :gateway, :polymorphic => true
t.string :trans_id, :limit => 30
t.string :description, :limit => 50
t.timestamps
end
end
def self.down
drop_table :ipns
end
end
include UriValidator
alias_attribute :account, :business
attr_accessible :business, :account, :return_url
validates_presence_of :account, :return_url
validates_uniqueness_of :business, :scope => :payable_type, :message => "account has already been used.", :case_sensitive => false
def validate
errors.add(:return_url, 'format invalid.') unless self.return_url.blank? || validate_http(self.return_url)
end
validates_presence_of :trans_id
validates_uniqueness_of :trans_id, :scope => :gateway_type, :allow_nil => true, :allow_blank => true
attr_accessible :trans_id, :description, :user, :gateway
module UriValidator
def validate_http uri
require 'uri'
return false if uri.blank?
uri = "http://" + uri unless uri.index("http") == 0
uri = URI.parse(uri)
if uri.class != URI::HTTP
return false
end
true
rescue URI::InvalidURIError
return false
end
end
def self.to_xml_params(data)
if data.is_a? Hash
data.collect do |key, value|
tag_attr = []
if key.is_a? Array
tag = key.first
key[1..-1].each do |key_attr|
key_attr.each do |k, v|
tag_attr << "#{k}=\"#{v}\""
end
end
else
tag = key
end
tag = tag.to_s.tr('_', '-')
result = "<#{tag}#{" #{tag_attr.join(' ')}" unless tag_attr.empty?}>"
result << to_xml_params(value)
result << "</#{tag}>"
result
end.join('')
elsif data.is_a? Array
data.inject(''){|result, v|
result << to_xml_params(v)
}
else
data.to_s
end
end
to_xml_params :a => "b"
# -> b
to_xml_params :a => {:b => "c"}
# -> c
to_xml_params [:a,{:x => :y}] => {:b => "c"}
# -> c
to_xml_params [:a,{:x => :y, :z => "w"}] => {[:b, {:p => "q"}] => "c"}
# -> c
to_xml_params :a => {:b => "c", :d => "e"}
# ->e c
to_xml_params :a => [{:b => "c"}, {:d => "e"}]
# -> ce sama dengan diatas
whenever --update-crontab MyApp
.... svn up, rsync, etc ....
cd /home/rails/myapp && whenever --update-crontab MyApp --set environment=staging
cd /home/rails/myapp/script && chmod 755 runner
every 30.minutes do
runner "QueuedEmail.deliver_all"
end
every 10.minutes do
runner "Message.destroy_all_expired"
end
every :day do
runner "ReferData.give_rewards!"
runner "SystemMailer.deliver_scheduler_check"
end
"Usahakan agar setiap update yang ditambahkan di staging selesai dalam sesedikit mungkin commit"
<form>
<input type="text" name="user_name" />
<div id="part1">
<input type="text" name="user_paid_amount" onchange="ajaxRequestToGetPart2ValueBasedOnPart1();" />
<input type="text" name="user_type" onchange="ajaxRequestToGetPart2ValueBasedOnPart1();"/>
</div>
<div id="part2">
<input type="text" name="price_amount" value="" />
</div>
</form>
function serialize(container){
//container: string selector or element of the container
$(':input', container).serialize();
}
serialize('#part1');
# views/frontpages/show.html.erb
<h3>Title</h3>
<%= render :partial => params[:page] || "home" %>
# /controllers/frontpages_controller.rb
# ...
def show
@partial = (params[:page].blank? ||
params[:page].try('include?', '/')) ?
'home' : params[:page]
end
# ...
# views/frontpages/show.html.erb
<h3>Title</h3>
<%= render :partial => @partial %>
branching -- trunk
-- branches
-- tags
branching -- trunk -- app
-- config
-- db
-- dll..
-- branches
-- tags
branching -- trunk -- app
-- config
-- db
-- dll..
-- branches -- staging -- app
-- config
-- dll..
-- tags
# layouts/application.html.erb
# ...
<div class="menu">
<%= render :partial => "main_menu" %>
</div>
<div class="content">
<%= yield %>
</div>
# ...
# layouts/application.html.erb
# ...
<div class="menu">
<% begin %>
<%= render :partial => "layouts/#{controller.controller_path}_menu" %>
<% rescue ActionView::MissingTemplate %>
<% begin %>
<%= render :partial => "layouts/#{controller.controller_path.sub(/#{controller.controller_name}$/,'default_menu')}" %>
<% rescue ActionView::MissingTemplate %>
<%= render :partial => "main_menu" %>
<% end %>
<% end %>
</div>
<div class="content">
<%= yield %>
</div>
# ...
# ...
<div class="menu">
<%= yield :menu %>
</div>
<div class="content">
<%= yield %>
</div>
# ...
# ...
<% content_for :menu, generate_menu %>
# ...
# ...
@content_for_menu = generate_menu
# ...
gem install rufus-scheduler
scheduler = Rufus::Scheduler.start_new
scheduler.every("10m") do
QueuedEmail.deliver_all
end
class CreateQueuedEmails < ActiveRecord::Migration
def self.up
create_table :queued_emails do |t|
t.string :from, :limit => 100
t.string :recipients, :limit => 100
t.string :subject, :limit => 100
t.text :content
t.integer :duration
t.datetime :send_at
t.datetime :last_sent_at
t.timestamps
end
end
def self.down
drop_table :queued_emails
end
end
class QueuedEmail < ActiveRecord::Base
validates_presence_of :from
validates_length_of :from, :within => 6..100
validates_presence_of :recipients
validates_length_of :recipients, :within => 6..100
def recurring?
!self.duration.blank?
end
def deliver!
puts "Sending email: #{self.inspect}"
UserMailer.deliver_custom_mail self.attributes
if recurring?
puts "set sent at: #{Time.now.utc}"
self.update_attribute :last_sent_at, Time.now.utc
else
puts "destroy"
self.destroy
end
end
def self.deliver_all
mails = self.all :conditions => ["(send_at <= :current_time) AND (duration IS NULL OR duration = \"\" OR last_sent_at IS NULL OR TIME_TO_SEC(TIMEDIFF(:current_time, last_sent_at)) >= duration)", {:current_time => Time.now.utc}]
mails.each do |mail|
mail.deliver!
end
end
end
def custom_mail(options)
@recipients = options["recipients"]
@from = options["from"]
@subject = options["subject"]
@sent_on = Time.now
@body[:content] = options["content"]
end
<%= @content %>
# ....
# bila registrasi sukses daftarkan email untuk dikirim setelah 2 hari
QueuedEmail.create(
:send_at => 2.days.since(Time.now.utc),
:from => "\"Site Keren\"",
:recipients => "#{@user.email}",
:subject => "Survey supaya keren" ,
:content => "Halo #{@user.name}, isi survey berikut supaya kamu makin keren gitu loh ....."
)
# ....
:duration => 24.hours