I'm getting the following error when I'm trying to query another table in a model definition.
PG::UndefinedTable: ERROR: missing FROM-clause entry for table "miq_user_roles" LINE 1: ..." = $1 AND "service_templates"."display" = $2 AND "miq_user_... ^ [catalog/explorer]
Any idea how to resolve this?
scope :with_service_template_catalog_id, ->(cat_id) { where(:service_template_catalog_id => cat_id) }
scope :without_service_template_catalog_id, -> { where(:service_template_catalog_id => nil) }
scope :with_existent_service_template_catalog_id, -> { where.not(:service_template_catalog_id => nil) }
scope :displayed, -> { where(:display => true) }
scope :public_service_templates, -> { where("miq_user_roles.settings" => nil) }
Here is the full code:
class ServiceTemplate < ApplicationRecord
include SupportsFeatureMixin
DEFAULT_PROCESS_DELAY_BETWEEN_GROUPS = 120
GENERIC_ITEM_SUBTYPES = {
"custom" => N_("Custom"),
"vm" => N_("Virtual Machine"),
"playbook" => N_("Playbook"),
"hosted_database" => N_("Hosted Database"),
"load_balancer" => N_("Load Balancer"),
"storage" => N_("Storage")
}.freeze
SERVICE_TYPE_ATOMIC = 'atomic'.freeze
SERVICE_TYPE_COMPOSITE = 'composite'.freeze
RESOURCE_ACTION_UPDATE_ATTRS = [:dialog,
:dialog_id,
:fqname,
:configuration_template,
:configuration_template_id,
:configuration_template_type].freeze
include CustomActionsMixin
include ServiceMixin
include OwnershipMixin
include NewWithTypeStiMixin
include TenancyMixin
include ArchivedMixin
include CiFeatureMixin
include_concern 'Filter'
include_concern 'Copy'
validates :name, :presence => true
belongs_to :tenant
has_many :service_templates, :through => :service_resources, :source => :resource, :source_type => 'ServiceTemplate'
has_many :services
has_many :service_template_tenants, :dependent => :destroy
has_many :additional_tenants, :through => :service_template_tenants, :source => :tenant, :dependent => :destroy
has_one :picture, :dependent => :destroy, :as => :resource, :autosave => true
belongs_to :service_template_catalog
belongs_to :zone
belongs_to :currency, :inverse_of => false
has_many :dialogs, -> { distinct }, :through => :resource_actions
has_many :miq_schedules, :as => :resource, :dependent => :destroy
has_many :miq_requests, :as => :source, :dependent => :nullify
has_many :active_requests, -> { where(:request_state => MiqRequest::ACTIVE_STATES) }, :as => :source, :class_name => "MiqRequest"
virtual_column :type_display, :type => :string
virtual_column :template_valid, :type => :boolean
virtual_column :template_valid_error_message, :type => :string
virtual_column :archived, :type => :boolean
virtual_column :active, :type => :boolean
default_value_for :internal, false
default_value_for :service_type, SERVICE_TYPE_ATOMIC
default_value_for(:generic_subtype) { |st| 'custom' if st.prov_type == 'generic' }
virtual_has_one :config_info, :class_name => "Hash"
scope :with_service_template_catalog_id, ->(cat_id) { where(:service_template_catalog_id => cat_id) }
scope :without_service_template_catalog_id, -> { where(:service_template_catalog_id => nil) }
scope :with_existent_service_template_catalog_id, -> { where.not(:service_template_catalog_id => nil) }
scope :displayed, -> { where(:display => true) }
scope :public_service_templates, -> { where("miq_user_roles.settings" => nil) }
supports :order do
unsupported_reason_add(:order, 'Service template does not belong to a service catalog') unless service_template_catalog
unsupported_reason_add(:order, 'Service template is not configured to be displayed') unless display
end
alias orderable? supports_order?
alias validate_order supports_order?
def self.with_tenant(tenant_id)
tenant = Tenant.find(tenant_id)
where(:tenant_id => tenant.ancestor_ids + [tenant_id])
end
def self.with_additional_tenants
references(table_name, :tenants).includes(:service_template_tenants => :tenant)
end
def self.all_catalog_item_types
#all_catalog_item_types ||= begin
builtin_catalog_item_types = {
"generic" => N_("Generic"),
"generic_orchestration" => N_("Orchestration"),
}
ExtManagementSystem.subclasses_supporting(:catalog)
.flat_map(&:catalog_types)
.reduce(builtin_catalog_item_types, :merge)
end
end
def self.catalog_item_types
ems_classes = Rbac.filtered(ExtManagementSystem.all).collect(&:class).uniq.select { |ems| ems.supports?(:catalog) }
ci_types = Set.new(ems_classes.flat_map(&:catalog_types).reduce({}, :merge).keys)
ci_types.add('generic_orchestration') if Rbac.filtered(OrchestrationTemplate).exists?
ci_types.add('generic')
all_catalog_item_types.each.with_object({}) do |(key, description), hash|
hash[key] = {:description => description, :display => ci_types.include?(key)}
end
end
def self.create_catalog_item(options, auth_user)
transaction do
create_from_options(options).tap do |service_template|
config_info = options[:config_info].except(:provision, :retirement, :reconfigure)
workflow_class = MiqProvisionWorkflow.class_for_source(config_info[:src_vm_id])
if workflow_class
request = workflow_class.new(config_info, auth_user).make_request(nil, config_info)
service_template.add_resource(request)
end
service_template.create_resource_actions(options[:config_info])
end
end
end
def self.class_from_request_data(data)
request_type = data['prov_type']
if request_type.include?('generic_')
generic_type = request_type.split('generic_').last
"ServiceTemplate#{generic_type.camelize}".constantize
else
ServiceTemplate
end
end
def update_catalog_item(options, auth_user = nil)
config_info = validate_update_config_info(options)
unless config_info
update!(options)
return reload
end
transaction do
update_from_options(options)
update_service_resources(config_info, auth_user)
update_resource_actions(config_info)
save!
end
reload
end
def children
service_templates
end
def descendants
children.flat_map { |child| [child] + child.descendants }
end
def subtree
[self] + descendants
end
def vms_and_templates
[]
end
def destroy
if parent_services.present?
raise MiqException::MiqServiceError, _("Cannot delete a service that is the child of another service.")
end
service_resources.each do |sr|
rsc = sr.resource
rsc.destroy if rsc.kind_of?(MiqProvisionRequestTemplate)
end
super
end
def archive
raise _("Cannot archive while in use") unless active_requests.empty?
archive!
end
def retireable?
false
end
def request_class
ServiceTemplateProvisionRequest
end
def request_type
"clone_to_service"
end
def config_info
options[:config_info] || construct_config_info
end
def create_service(service_task, parent_svc = nil)
nh = attributes.dup
# Service#display was renamed to #visible in https://github.com/ManageIQ/manageiq-schema/pull/410
nh['visible'] = nh.delete('display') if nh.key?('display')
nh['options'][:dialog] = service_task.options[:dialog]
(nh.keys - Service.column_names + %w(created_at guid service_template_id updated_at id type prov_type)).each { |key| nh.delete(key) }
# Hide child services by default
nh['visible'] = false if parent_svc
# If visible is nil, set it to false
nh['visible'] ||= false
# convert template class name to service class name by naming convention
nh['type'] = self.class.name.sub('Template', '')
nh['initiator'] = service_task.options[:initiator] if service_task.options[:initiator]
service = Service.create!(nh) do |svc|
svc.service_template = self
set_ownership(svc, service_task.get_user)
service_resources.each do |sr|
nh = sr.attributes.dup
%w(id created_at updated_at service_template_id).each { |key| nh.delete(key) }
svc.add_resource(sr.resource, nh) unless sr.resource.nil?
end
end
service.tap do |svc|
if parent_svc
service_resource = ServiceResource.find_by(:id => service_task.options[:service_resource_id])
parent_svc.add_resource!(svc, service_resource)
end
end
end
def composite?
service_type.to_s.include?(self.class::SERVICE_TYPE_COMPOSITE)
end
def atomic?
service_type.to_s.include?(self.class::SERVICE_TYPE_ATOMIC)
end
def type_display
case service_type
when self.class::SERVICE_TYPE_ATOMIC then "Item"
when self.class::SERVICE_TYPE_COMPOSITE then "Bundle"
when nil then "Unknown"
else
service_type.to_s.capitalize
end
end
def create_tasks_for_service(service_task, parent_svc)
unless parent_svc
return [] unless self.class.include_service_template?(service_task,
service_task.source_id,
parent_svc)
end
svc = create_service(service_task, parent_svc)
service_task.destination = svc
create_subtasks(service_task, svc)
end
# default implementation to create subtasks from service resources
def create_subtasks(parent_service_task, parent_service)
tasks = []
service_resources.each do |child_svc_rsc|
scaling_min = child_svc_rsc.scaling_min
1.upto(scaling_min).each do |scaling_idx|
nh = parent_service_task.attributes.dup
%w(id created_on updated_on type state status message).each { |key| nh.delete(key) }
nh['options'] = parent_service_task.options.dup
nh['options'].delete(:child_tasks)
# Initial Options[:dialog] to an empty hash so we do not pass down dialog values to child services tasks
nh['options'][:dialog] = {}
next if child_svc_rsc.resource_type == "ServiceTemplate" &&
!self.class.include_service_template?(parent_service_task,
child_svc_rsc.resource.id,
parent_service)
new_task = parent_service_task.class.new(nh)
new_task.options.merge!(
:src_id => child_svc_rsc.resource.id,
:scaling_idx => scaling_idx,
:scaling_min => scaling_min,
:service_resource_id => child_svc_rsc.id,
:parent_service_id => parent_service.id,
:parent_task_id => parent_service_task.id,
)
new_task.state = 'pending'
new_task.status = 'Ok'
new_task.source = child_svc_rsc.resource
new_task.save!
new_task.after_request_task_create
parent_service_task.miq_request.miq_request_tasks << new_task
tasks << new_task
end
end
tasks
end
def set_ownership(service, user)
return if user.nil?
service.evm_owner = user
if user.current_group
$log.info("Setting Service Owning User to Name=#{user.name}, ID=#{user.id}, Group to Name=#{user.current_group.name}, ID=#{user.current_group.id}")
service.miq_group = user.current_group
else
$log.info("Setting Service Owning User to Name=#{user.name}, ID=#{user.id}")
end
end
def self.default_provisioning_entry_point(service_type)
if service_type == 'atomic'
'/Service/Provisioning/StateMachines/ServiceProvision_Template/CatalogItemInitialization'
else
'/Service/Provisioning/StateMachines/ServiceProvision_Template/CatalogBundleInitialization'
end
end
def self.default_retirement_entry_point
'/Service/Retirement/StateMachines/ServiceRetirement/Default'
end
def self.default_reconfiguration_entry_point
nil
end
def template_valid?
validate_template[:valid]
end
alias template_valid template_valid?
def template_valid_error_message
validate_template[:message]
end
def validate_template
missing_resources = service_resources.select { |sr| sr.resource.nil? }
if missing_resources.present?
missing_list = missing_resources.collect { |sr| "#{sr.resource_type}:#{sr.resource_id}" }.join(", ")
return {:valid => false,
:message => "Missing Service Resource(s): #{missing_list}"}
end
service_resources.detect do |s|
r = s.resource
r.respond_to?(:template_valid?) && !r.template_valid?
end.try(:resource).try(:validate_template) || {:valid => true, :message => nil}
end
def provision_action
resource_actions.find_by(:action => "Provision")
end
def update_resource_actions(ae_endpoints)
resource_action_list.each do |action|
resource_params = ae_endpoints[action[:param_key]]
resource_action = resource_actions.find_by(:action => action[:name])
# If the action exists in updated parameters
if resource_params
# And the resource action exists on the template already, update it
if resource_action
resource_action.update!(resource_params.slice(*RESOURCE_ACTION_UPDATE_ATTRS))
# If the resource action does not exist, create it
else
build_resource_action(resource_params, action)
end
elsif resource_action
# If the endpoint does not exist in updated parameters, but exists on the template, delete it
resource_action.destroy
end
end
end
def create_resource_actions(ae_endpoints)
ae_endpoints ||= {}
resource_action_list.each do |action|
ae_endpoint = ae_endpoints[action[:param_key]]
next unless ae_endpoint
build_resource_action(ae_endpoint, action)
end
save!
end
def self.create_from_options(options)
create!(options.except(:config_info).merge(:options => { :config_info => options[:config_info] }))
end
private_class_method :create_from_options
def provision_request(user, options = nil, request_options = {})
request_options[:provision_workflow] = true
request_options[:parent_id] = options.delete('param_parent_request_id') unless options['param_parent_request_id'].nil?
result = order(user, options, request_options)
raise result[:errors].join(", ") if result[:errors].any?
result[:request]
end
def picture=(value)
if value.kind_of?(Hash)
super(Picture.new(value))
else
super
end
end
def queue_order(user_id, options, request_options)
MiqQueue.submit_job(
:class_name => self.class.name,
:instance_id => id,
:method_name => "order",
:args => [user_id, options, request_options],
)
end
def order(user_or_id, options = nil, request_options = {}, schedule_time = nil)
user = user_or_id.kind_of?(User) ? user_or_id : User.find(user_or_id)
workflow = provision_workflow(user, options, request_options)
if schedule_time
require 'time'
time = Time.parse(schedule_time).utc
errors = workflow.validate_dialog
errors << unsupported_reason(:order)
return {:errors => errors} if errors.compact.present?
schedule = MiqSchedule.create!(
:name => "Order #{self.class.name} #{id} at #{time}",
:description => "Order #{self.class.name} #{id} at #{time}",
:sched_action => {:args => [user.id, options, request_options], :method => "queue_order"},
:resource => self,
:run_at => {
:interval => {:unit => "once"},
:start_time => time,
:tz => "UTC",
},
)
{:schedule => schedule}
else
workflow.submit_request
end
end
def provision_workflow(user, dialog_options = nil, request_options = {})
dialog_options ||= {}
request_options.delete(:provision_workflow) if request_options[:submit_workflow]
ra_options = request_options.slice(:initiator, :init_defaults, :provision_workflow, :submit_workflow).merge(:target => self)
ResourceActionWorkflow.new(dialog_options, user, provision_action, ra_options).tap do |wf|
wf.request_options = request_options
end
end
def add_resource(rsc, options = {})
super
adjust_service_type
end
def self.display_name(number = 1)
n_('Service Catalog Item', 'Service Catalog Items', number)
end
def my_zone
# Catalog items can specify a zone to run in.
# Catalog bundle are used for grouping catalog items and are therefore treated as zone-agnostic.
zone&.name if atomic?
end
private
def update_service_resources(config_info, auth_user = nil)
config_info = config_info.except(:provision, :retirement, :reconfigure)
workflow_class = MiqProvisionWorkflow.class_for_source(config_info[:src_vm_id])
if workflow_class
service_resources.find_by(:resource_type => 'MiqRequest').try(:destroy)
new_request = workflow_class.new(config_info, auth_user).make_request(nil, config_info)
add_resource!(new_request)
end
end
def build_resource_action(ae_endpoint, action)
fqname = ae_endpoint[:fqname] || self.class.send(action[:method], *action[:args]) || ""
build_options = {:action => action[:name],
:fqname => fqname,
:ae_attributes => {:service_action => action[:name]}}
build_options.merge!(ae_endpoint.slice(*RESOURCE_ACTION_UPDATE_ATTRS))
resource_actions.build(build_options)
end
def validate_update_config_info(options)
if options[:service_type] && options[:service_type] != service_type
raise _('service_type cannot be changed')
end
if options[:prov_type] && options[:prov_type] != prov_type
raise _('prov_type cannot be changed')
end
options[:config_info]
end
def resource_action_list
[
{:name => ResourceAction::PROVISION,
:param_key => :provision,
:method => 'default_provisioning_entry_point',
:args => [service_type]},
{:name => ResourceAction::RECONFIGURE,
:param_key => :reconfigure,
:method => 'default_reconfiguration_entry_point',
:args => []},
{:name => ResourceAction::RETIREMENT,
:param_key => :retirement,
:method => 'default_retirement_entry_point',
:args => []}
]
end
def update_from_options(params)
options[:config_info] = params[:config_info]
update!(params.except(:config_info))
end
def construct_config_info
config_info = {}
miq_request_resource = service_resources.find_by(:resource_type => 'MiqRequest')
config_info.merge!(miq_request_resource.resource.options.compact) if miq_request_resource
config_info.merge!(resource_actions_info)
end
def resource_actions_info
resource_actions.each_with_object({}) do |resource_action, config_info|
resource_options = resource_action.slice(:dialog_id, :configuration_template_type, :configuration_template_id).compact
resource_options[:fqname] = resource_action.fqname
config_info[resource_action.action.downcase.to_sym] = resource_options.symbolize_keys
end
end
def generic_custom_buttons
CustomButton.buttons_for("Service")
end
def adjust_service_type
self.service_type = service_resources.any? { |st| st.resource_type.in?(['Service', 'ServiceTemplate']) } ? self.class::SERVICE_TYPE_COMPOSITE : self.class::SERVICE_TYPE_ATOMIC
end
end
scope :public_service_templates, -> {
joins(:miq_user_roles).where(miq_user_roles: { settings: nil })
}
Assuming the table exists. You need to join on that table in order to query it. Note, the default joins is an inner join that will remove records that don't have an associated miq_user_roles.
This will change the query substantially. If a record has_many miq_user_roles you'll likely need to add a distinct or distinct on clause. If it's possible to have no miq_user_roles, then records without them will now dissappear when you call the scope, since the inner join didn't find any.
I'm trying to import 90k lines of xml into my ruby app. herokus timeout limit is 30s so i'm trying to use delayed job.
The import class works wonderfully in around 48-hippopotomuses locally. When i add the line
handle_asynchronously :save_races
I get the error "undefined method save_races' for classXmltube'"
What am i doing wrong with DJ and how can i get this to work?
Full class code below
require "rexml/document"
class Xmltube
def self.convert_save(xml_data)
doc = REXML::Document.new xml_data.read
doc.elements.each("Meeting") do |meeting_element|
meeting = save_meeting(meeting_element)
save_races(meeting_element, meeting)
Rails.logger.info "all done"
end
end
def self.save_races(meeting_element, meeting)
meeting_element.elements.each("Races/Race") do |race_element|
race = save_race(race_element, meeting)
save_race_entrants(race_element, race)
end
end
def self.save_race_entrants(race_element, race)
race_element.elements.each("RaceEntries/RaceEntry") do |entry_element|
horse = save_horse(entry_element)
jockey = save_jockey(entry_element)
start = save_start(entry_element, horse, jockey, race)
save_sumaries(entry_element, start)
end
end
def self.save_track(meeting_element)
# there is only one track, but still, each? wtf.
t = {}
meeting_element.elements.each("Track") do |track|
t = {
:name => track.attributes["VenueName"],
:track_code => track.attributes["VenueCode"],
:condition => track.elements['TrackRating'].text,
:club_id => save_club(meeting_element.elements["Club"]).id
}
end
track = Track.where(:track_code => t[:track_code] ).first
if track
Track.update(track.id, t)
else
Track.create(t)
end
end
def self.save_meeting meeting_element
t = {
:meet_code => meeting_element.attributes['MeetCode'],
:stage => meeting_element.elements["MeetingStage"].text,
:phase => meeting_element.elements["MeetingPhase"].text,
:nominations_close_at => meeting_element.elements["NominationsClose"].text,
:acceptance_close_at => meeting_element.elements["AcceptanceClose"].text,
:riders_close_at => meeting_element.elements["RidersClose"].text,
:weights_published_at => meeting_element.elements["WeightsPublishing"].text,
:club_id => save_club(meeting_element.elements["Club"]).id ,
:track_id => save_track(meeting_element).id,
:tab_status => meeting_element.elements["TabStatus"].text,
:state => meeting_element.elements["StateDesc"].text,
:day_night => meeting_element.elements["DayNight"].text,
:number_of_races => meeting_element.elements["NumOfRaces"].text,
:meet_date => meeting_element.elements["MeetDate"].text,
}
meeting = Meeting.where(:meet_code => t[:meet_code] ).first
if meeting
Meeting.update(meeting.id, t)
else
Meeting.create(t)
end
end
############################################################
def self.save_sumaries entry_element, start
entry_element.elements.each('Form/ResultsSummaries/ResultsSummary') do | element |
s = {
:name => element.attributes['Name'],
:start_id => start.id,
:starts => element.attributes['Starts'],
:wins => element.attributes['Wins'],
:seconds => element.attributes['Seconds'],
:thirds => element.attributes['Thirds'],
:prize_money => element.attributes['PrizeMoney'],
}
sum = Summary.where(:name => s[:name] ).where(:start_id => s[:start_id]).first
if sum
Summary.update(sum.id, s)
else
Summary.create(s)
end
end
end
def self.save_start entry_element, horse, jockey, race
s = {
:horse_id => horse.id,
:jockey_id => jockey.id,
:race_id => race.id,
:silk => entry_element.elements["JockeySilksImage"].attributes["FileName_NoExt"],
:start_code => entry_element.attributes['RaceEntryCode'],
:handicap_weight => entry_element.elements['HandicapWeight'].text,
}
# Rails.logger.info entry_element['HandicapWeight'].text
start = Start.where(:start_code => s[:start_code] ).first
if start
Start.update(start.id, s)
else
Start.create(s)
end
end
def self.save_jockey entry_element
j={
:name => entry_element.elements['JockeyRaceEntry/Name'].text,
:jockey_code => entry_element.elements['JockeyRaceEntry'].attributes["JockeyCode"],
}
jockey = Jockey.where(:jockey_code => j[:jockey_code] ).first
if jockey
Jockey.update(jockey.id, j)
else
Jockey.create(j)
end
end
def self.save_horse entry_element
trainer = save_trainer entry_element
h= {
:name => entry_element.elements['Horse'].attributes["HorseName"],
:color => entry_element.elements['Horse'].attributes["Colour"],
:dob => entry_element.elements['Horse'].attributes["FoalDate"],
:sex => entry_element.elements['Horse'].attributes["Sex"],
:trainer_id => trainer.id,
:horse_code => entry_element.elements['Horse'].attributes["HorseCode"],
}
horse = Horse.where(:horse_code => h[:horse_code] ).first
if horse
Horse.update(horse.id, h)
else
Horse.create(h)
end
end
def self.save_trainer entry_element
t= {
:name => entry_element.elements['Trainer/Name'].text,
:trainer_code => entry_element.elements['Trainer'].attributes["TrainerCode"]
}
trainer = Trainer.where(:trainer_code => t[:trainer_code] ).first
if trainer
Trainer.update(trainer.id, t)
else
Trainer.create(t)
end
end
def self.save_club element
t = {}
t = {
:club_code => element.attributes['ClubCode'],
:title => element.attributes["Title"],
}
club = Club.where(:club_code => t[:club_code] ).first
if club
Club.update(club.id, t)
else
Club.create(t)
end
end
def self.save_race element, meeting
r = {
:name => element.elements['NameRaceFull'].text,
:occur => element.elements['RaceStartTime'].attributes["TimeAtVenue"],
:distance => element.elements['RaceDistance'].text,
:race_type => element.elements['RaceType'].text,
:track_id => meeting.track_id,
:race_code => element.attributes["RaceCode"],
:meeting_id => meeting.id
}
race = Race.where(:race_code => r[:race_code] ).first
if race
Race.update(race.id, r)
else
Race.create(r)
end
end
handle_asynchronously :save_races
end
Since your save_races is a class method, you should call handle_asynchronously on Xmltube's singleton class:
class << self
handle_asynchronously :save_races
end
This just worked as I would expect
class Foo
def self.bar(s)
Rails.logger.info "From Foo.bar('#{s}')"
end
end
# then ...
Foo.delay.bar('hello')
I was running 4.0.4 of DJ with ruby 2.1
I Have a ROR IF statement that is supposed to look up a record and then send emails based on the login can anyone tell me what is wrong in the syntax?
this is now working but there is two test cases that return ActiveRecord::RecordNotFound (Couldn't find SignOn with userw1 = xxx#example.com):
app/models/order.rb:219:in `submit_order'
class Order < ActiveRecord::Base
# NOTE: ensure that you always setup methods here to include and filter on
# query_account_number as a security measure.
establish_connection "web_#{RAILS_ENV}"
has_many :order_details, :dependent => :destroy, :order => 'id DESC'
def self.delete_item query_account_number, login, id
order = Order.first(:conditions => {:account_number => query_account_number, :login => login})
detail = order.order_details.first(:conditions => {:id => id})
detail.destroy if detail
# Here we would delete the order, but have chosen to leave it so they do not have
# questionable gaps in IDs.
end
def self.verify_upc1 upc_rule, upc1
"Invalid UPC Prefix" unless Item.first(:conditions => ["rul31c = ? AND CONCAT(TRIM(comi1c), 'A') = ?", upc_rule, upc1 + "A"],
:select => "style")
end
def self.verify_upc2 upc_rule, upc1, upc2
"Invalid UPC Prefix or Subnumber" unless Item.first(:conditions => ["rul31c = ? AND CONCAT(TRIM(comi1c), CONCAT(TRIM(arsb1c), 'A')) = ?", upc_rule, upc1 + upc2 + "A"],
:select => "style")
end
def self.verify_style upc_rule, style
"Invalid Style" unless Item.first(:conditions => ["rul31c = ? AND CONCAT(TRIM(style), 'A') = ?", upc_rule, style + "A"],
:select => "style")
end
def self.update_quantity query_account_number, login, id, quantity
if quantity.to_i > 0
order = Order.first(:conditions => {:account_number => query_account_number, :login => login})
detail = order.order_details.first(:conditions => {:id => id})
if detail
detail.quantity = quantity.to_i
detail.save
end
end
end
def self.update_order_note query_account_number, login, order_note
order = Order.first(:conditions => {:account_number => query_account_number, :login => login})
order.note = order_note
order.save
end
def self.update_order_item_note query_account_number, login, id, note
order = Order.first(:conditions => {:account_number => query_account_number, :login => login})
detail = order.order_details.first(:conditions => {:id => id})
if detail
detail.note = note
detail.save
end
end
def self.add_item query_account_number, login, quantity, upc1, upc2, price_code, upc_rule
if quantity.to_i > 0
order = Order.first(:conditions => {:account_number => query_account_number, :login => login})
order = Order.add_order_header(query_account_number, login) if order.blank?
if order
item = Item.first(:conditions => ["rul31c = ? AND CONCAT(TRIM(comi1c), CONCAT(TRIM(arsb1c), 'A')) = ?", upc_rule, upc1 + upc2 + "A"],
:select => "style, color, size, pnum35, cono35, comi1c, arsb1c, ptyp35")
price = Price.first(:conditions => {:catnwp => item.pnum35, :conowp => item.cono35, :listwp => price_code}, :select => "prcewp") unless item.blank?
if item and price
order_detail = OrderDetail.new(:style => item.style,
:order_id => order.id,
:quantity => quantity,
:color => item.color,
:size => item.size)
order_detail.save
# Return a cart item hash
cart_contents = []
cart_contents << {:style => item.style,
:color => item.color,
:size => item.size,
:quantity => quantity,
:name => ProItem.short_description(item.style),
:price => price.prcewp,
:type => item.ptyp35,
:upc => item.comi1c + item.arsb1c,
:id => order_detail.id}
end
end
end
end
def self.order_info_update query_account_number, login, info
order = Order.first(:conditions => {:account_number => query_account_number, :login => login})
if order
if info.has_key?("name")
order.name = info[:name]
order.address1 = info[:address1]
order.address2 = info[:address2]
order.address3 = info[:address3]
order.city = info[:city]
order.state = info[:state]
order.zip = info[:zip]
end
if info.has_key?("po_number")
order.po_number = info[:po_number]
end
order.save
# where does po number go???
end
end
def self.mailing_address query_account_number, login
o = Order.first(:conditions => {:account_number => query_account_number, :login => login})
{:name => o.name, :address1 => o.address1, :address2 => o.address2, :address3 => o.address3, :city => o.city, :state => o.state, :zip => o.zip} if o
end
def self.order_note query_account_number, login
o = Order.first(:conditions => {:account_number => query_account_number, :login => login}, :select => "note")
o.note if o
end
def self.cart_contents query_account_number, login, price_code, upc_rule
# TODO: what to do if item changed since they put it in cart?
# Perhaps we expire a cart after a while, but, that still is not a perfect solution.
# Ideally here we go through each style, make sure it is still valid for the customer, and
# check color/size as well.
order_items = Order.first(:conditions => {:account_number => query_account_number, :login => login} )
if order_items
cart_contents = []
order_items.order_details.each do |oi|
as400_item = Item.first(:conditions => {:rul31c => upc_rule, :style => oi.style.ljust(9), :color => oi.color, :size => oi.size },
:select => "pnum35, cono35, ptyp35, comi1c, arsb1c")
price = Price.first(:conditions => {:catnwp => as400_item.pnum35, :conowp => as400_item.cono35, :listwp => price_code}, :select => "prcewp") unless as400_item.blank?
cart_contents << {:style => oi.style,
:color => oi.color,
:size => oi.size,
:quantity => oi.quantity,
:name => ProItem.short_description(oi.style),
:price => price.prcewp,
:type => as400_item.ptyp35,
:note => oi.note,
:upc => as400_item.comi1c + as400_item.arsb1c,
:id => oi.id} if as400_item and price
end unless order_items.blank?
cart_contents
end
end
def self.cart_contents_count query_account_number, login
order_items = Order.first(:conditions => {:account_number => query_account_number, :login => login} )
count = 0
order_items.order_details.each {|oi| count += oi.quantity } if order_items
count
end
def self.cart_contents_total query_account_number, login, price_code, upc_rule
order_items = Order.first(:conditions => {:account_number => query_account_number, :login => login} )
total = 0
order_items.order_details.each do |oi|
as400_item = Item.first(:conditions => {:rul31c => upc_rule, :style => oi.style.ljust(9), :color => oi.color, :size => oi.size },
:select => "pnum35, cono35, ptyp35")
price = 0
if !as400_item.blank?
price = Price.first(:conditions => {:catnwp => as400_item.pnum35, :conowp => as400_item.cono35, :listwp => price_code}, :select => "prcewp")
total += (oi.quantity * price.prcewp.to_f)
end
end if order_items
total
end
def self.add_order_details query_account_number, login, items, notes = Hash.new
result = false
if items
# If there is not an order record, create one. Basically we only
# allow one open order per login at a time, and if there is
# one already, we continue to append order_detail records to it.
order = Order.first(:conditions => {:account_number => query_account_number, :login => login.upcase})
order = Order.add_order_header(query_account_number, login) if order.blank?
items.each do |key, value|
if value.to_i > 0
result = true
style = key[0..8]
color = key[9..11]
size = key[12..14]
order_detail = OrderDetail.new(:style => style,
:order_id => order.id,
:quantity => value,
:color => color,
:size => size,
:note => (notes ? notes[key] : ''))
order_detail.save
end
end if order
end
result
end
def self.submit_order query_account_number, login, price_code, distributor_number
o = Order.first(:conditions => {:account_number => query_account_number, :login => login})
# TODO: transaction or some error handling
if o
# Find all associated records we need.
customer = Customer.first(:conditions => {:cusn05 => query_account_number}, :select => "cono05, cgp405, slmn05, list20" )
sign_on = SignOn.first(:conditions => {:userw1 => login.upcase},
:select => "idnow1, bsnamw1, accntw1, prfdstw1, cntacw1, bsadd1w1, bsadd2w1, bsadd3w1, bscityw1, bsstcdw1, bszipw1, acctypw1")
distributor = Distributor.first(:conditions => {:cusnp1 => distributor_number}, :select => "cnam05, emailp1")
if sign_on.acctypw1.strip == "DS"
rec = SignOn.find_by_userw1!(login)
webid = rec.prfdstw1
elsif sign_on.acctypw1.strip == "DSD"
rec = SignOn.find_by_userw1!(login)
webid = rec.prfdstw1
end
#cnt = Weboel23.count(:all,:conditions => {:act223 => mp})
weboel23 = Weboel23.first(:conditions => {:act223 => webid}, :select => "emal23")
#cnt=weboel23.count
approval0=Weboel23.get_email_by_account0(webid)
approval1=Weboel23.get_email_by_account1(webid)
approval2=Weboel23.get_email_by_account2(webid)
approval3=Weboel23.get_email_by_account3(webid)
approval4=Weboel23.get_email_by_account4(webid)
# weboel23 = Weboel23.each(:conditions => {:act223 => mp}, :select => "emal23")
#approval = weboel23.emal23
#f=File.open("/var/www/onlineordering.coastalpet.com/log/debug3.txt")
#establish_connection "as400_#{RAILS_ENV}"
#f.puts "prfdstw1"
#f.puts rec = SignOn.find_by_userw1!(login)
#f.puts "type="+elephant
#f.puts "email="+approval0
#f.close
# s = find_by_sql ["SELECT EMAL23 emal23 FROM WEBOEL23 WHERE ACT223 = ?", distributor_number]
# d << { :id => s[0].emal23 } unless s.blank?
if customer and sign_on
as400_order_id = "WB" + o.id.to_s.rjust(8, "0")
total = 0
count = 0
line = 1 # Start at 1 per Ron Hoopes 2/14/2011
o.order_details.each do |oi|
item = Item.first(:conditions => {:rul31c => customer.cgp405, :style => oi.style.ljust(9), :color => oi.color, :size => oi.size },
:select => "comi1c, arsb1c, chdt1c, pnum35, cono35, pdes35")
price = Price.first(:conditions => {:catnwp => item.pnum35, :conowp => item.cono35, :listwp => price_code}, :select => "prcewp") unless item.blank?
if item and price
WebOrderDetail.create(:conowd => customer.cono05,
:uniqwd => as400_order_id,
:linewd => line,
:itemwd => oi.style.ljust(9) + oi.color + oi.size,
:barcwd => item.comi1c.strip + item.arsb1c.strip + item.chdt1c.strip,
:altiwd => "",
:itmdwd => item.pdes35,
:qtywd => oi.quantity,
:uprcwd => price.prcewp.to_f.round_to(2),
:listwd => customer.list20,
:dtdrwd => "0",
:dcd1wd => "",
:dsc1wd => "0",
:dcd2wd => "",
:dsc2wd => "0")
# Create any order ITEM notes.
unless oi.note.blank?
oi.note.scan(/.{1,70}/).each_with_index do |note, index|
WebOrderNote.create(:conown => customer.cono05,
:textwn => note,
:uniqwn => as400_order_id,
:linewn => line,
:seqwn => index)
end
end
count += oi.quantity.to_i
total += oi.quantity.to_i * price.prcewp.to_f.round_to(2)
line += 1
end
end
# Create any order notes.
unless o.note.blank?
o.note.scan(/.{1,70}/).each_with_index do |note, index|
WebOrderNote.create(:conown => customer.cono05,
:textwn => note,
:uniqwn => as400_order_id,
:linewn => 0,
:seqwn => index)
end
end
# Coastal's definition a current century is off by one, hence the math for the date.
as400_order_header = WebOrder.new(:conowc => customer.cono05,
:uniqwc => as400_order_id,
:idnowc => sign_on.idnow1,
:namewc => o.name,
:addr1wc => o.address1,
:addr2wc => o.address2,
:addr3wc => o.address3,
:citywc => o.city,
:statewc => o.state,
:zipcdwc => o.zip,
:cusnwc => query_account_number,
:dtordwc => Utilities.to_db2_date(Date.today),
:shpdtwc => Utilities.to_db2_date(Date.today),
:cusowc => o.po_number.blank? ? as400_order_id : o.po_number,
:slmnwc => customer.slmn05,
:rulewc => customer.cgp405,
:listwc => customer.list20,
:valuewc => total.to_f.round_to(2),
:statwc => "")
if as400_order_header.save
# Sent confirmation email, if required. Only send it for users that chose a distributor,
# whether they had to choose one or not. We determine this by looking at the account number
# in the sign_on and comparing it with the order number we are using for the order. If
# that is different, it indicates that they chose a distributor.
# These are used in the email body, key for the hash is the replacement tags, capitalized, &
# prepended and appended with '##', e.g. ##NAME## - and any underlines are replaced with space
email_details = {"name" => sign_on.bsnamw1,
"order_number" => as400_order_id,
"order_total" => format('$%.2f', total),
"order_count" => count.to_s,
"order_date" => Date.today.to_s,
"distributor_name" => (distributor ? distributor.cnam05 : ""),
"distributor_contact" => "UNKNOWN",
"customer_name" => sign_on.bsnamw1,
"customer_address" => sign_on.bsadd1w1.strip + (!sign_on.bsadd2w1.blank? ? "<br>" + sign_on.bsadd2w1.strip : "") + (!sign_on.bsadd3w1.blank? ? "<br>" + sign_on.bsadd3w1.strip : ""),
"customer_city" => sign_on.bscityw1,
"customer_state" => sign_on.bsstcdw1,
"customer_zip" => sign_on.bszipw1,
"customer_contact" => sign_on.cntacw1}
Mailer.deliver_order_coastal_notify_email("Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation", email_details)
# Per Dana 6/30/2012, JUST DS
if sign_on.acctypw1.strip == "DS" or sign_on.acctypw1.strip == "DSD"
# If there is no distributor email address, the mailer model will substitute in the admin's email from their settings
Mailer.deliver_order_distributor_approval_email(distributor ? distributor.emailp1 : "", "Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation #{approval0} #{approval1}", email_details)
if approval0!=""
Mailer.deliver_order_confirmation_email(login, "Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation", email_details)
Mailer.deliver_order_distributor_approval_email(approval0, "Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation ", email_details)
Mailer.deliver_order_coastal_notify_email("Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation", email_details)
end
if approval1!=""
Mailer.deliver_order_confirmation_email(login, "Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation", email_details)
Mailer.deliver_order_distributor_approval_email(approval1, "Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation ", email_details)
Mailer.deliver_order_coastal_notify_email("Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation", email_details)
end
if approval2!=""
Mailer.deliver_order_confirmation_email(login, "Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation", email_details)
Mailer.deliver_order_distributor_approval_email(approval2, "Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation ", email_details)
Mailer.deliver_order_coastal_notify_email("Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation", email_details)
end
if approval3!=""
Mailer.deliver_order_confirmation_email(login, "Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation", email_details)
Mailer.deliver_order_distributor_approval_email(approval3, "Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation ", email_details)
Mailer.deliver_order_coastal_notify_email("Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation", email_details)
end
if approval4!=""
Mailer.deliver_order_confirmation_email(login, "Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation", email_details)
Mailer.deliver_order_distributor_approval_email(approval4, "Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation ", email_details)
Mailer.deliver_order_coastal_notify_email("Coastal Pet Online Ordering<noreply#coastalpet.com>", "Order Confirmation", email_details)
end
Mailer.deliver_order_distributor_approval_email(weboel23 ? weboel23.emal23: "", "Coastal Pet Online Ordering<noreply#coastalpet.com>", "*Order Confirmation", email_details)
Mailer.deliver_order_distributor_approval_email("robert.kendall#coastalpet.com", "Coastal Pet Online Ordering<noreply#coastalpet.com>", "*Order Confirmation", email_details)
end
# Al ways notify Coastal staff
# Update the last ordered date (used for reminders)
User.update_last_order_date(login)
o.destroy
as400_order_id
end
end
end
end
def self.count_user_orders query_account_number, login
count = Order.first(:conditions => {:account_number => query_account_number, :login => login})
count.order_details.count unless count.blank? or count == 0
end
def self.reorder(order_number, login, query_account_number, upc_rule, price_code, mode)
warnings = ""
# If we are not in check mode, then blank out cart
self.empty_cart(query_account_number, login) if mode != "check"
# Get the previous order
oo = WebOrder.get_previous_order(order_number, login)
# Go through each line item
oo.each do |ooi|
# Verify it still exists in the AS400 and is same price
# Note that this reports back a -1 if it cannot find the
# same style+color+size option, otherwise just reports
# price if it finds it.
current_price = Item.check_item_exists(query_account_number, ooi[:style], ooi[:color], ooi[:size], upc_rule, price_code)
# If item was not found, we can't add it.
# We could spend more time to determine if it was the color, or size, or that
# the style itself is not available, but it seems reasonable enough to
# present it this way. Really should not be doing this "presentation" in
# the model, but we don't have views setup for Ajax so we have to give the
# controller the text we want rendered.
if current_price == -1
warnings += "SKU "+ ooi[:style].to_s + ooi[:color].to_s + ooi[:size].to_s + " is no longer available<br />"
else
# If price did not match, append to list of warnings
if current_price.to_f.round_to(2) != ooi[:price].to_f.round_to(2)
warnings += "SKU "+ ooi[:style].to_s + ooi[:color].to_s + ooi[:size].to_s + " price is " +
ActionController::Base.helpers.number_to_currency(current_price) + " and it was " +
ActionController::Base.helpers.number_to_currency(ooi[:price]) + "<br />"
end
# If not in check mode, add item to cart
# In this case, we don't care that the price did
# not match, we still add it.
populate_cart(query_account_number, login, ooi[:style], ooi[:color], ooi[:size], ooi[:quantity], ooi[:line_item_note], ooi[:order_note]) if mode != "check"
end
end
mode == "check" ? warnings : ""
end
def self.empty_cart query_account_number, login
order = Order.first(:conditions => {:account_number => query_account_number, :login => login})
order.destroy if order
end
def self.populate_cart query_account_number, login, style, color, size, quantity, note, order_note
# If there is not an order record, create one. Basically we only
# allow one open order per login at a time, and if there is
# one already, we continue to append order_detail records to it.
order = Order.first(:conditions => {:account_number => query_account_number, :login => login.upcase})
order = Order.add_order_header(query_account_number, login) if order.blank?
# These can be null for kits, and we don't like nulls in the database for this
color = "" if color.blank?
size = "" if size.blank?
if order
order.note = order_note # yeah we do this each time but while inefficient it works
order.save
order_detail = OrderDetail.new(:style => style,
:order_id => order.id,
:quantity => quantity,
:color => color,
:size => size,
:note => note)
order_detail.save
end
end
private
def self.add_order_header query_account_number, login
# Default address info to sign_on
sign_on = SignOn.first(:conditions => {:userw1 => login.upcase}, :select => "bsnamw1, bsadd1w1, bsadd2w1, bsadd3w1, bscityw1, bsstcdw1, bszipw1")
if sign_on
order = Order.new(:login => login,
:account_number => query_account_number,
:name => sign_on.bsnamw1,
:address1 => sign_on.bsadd1w1,
:address2 => sign_on.bsadd2w1,
:address3 => sign_on.bsadd3w1,
:city => sign_on.bscityw1,
:state => sign_on.bsstcdw1,
:zip => sign_on.bszipw1)
order.save
order
end
end
end
Hi i have a controller in rails but it gives me an error
ActiveRecord::StatementInvalid in StreamsController#front_page
Mysql2::Error: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'EPOCH FROM posts.created_at) - 1327654606)/9000) desc LIMIT 15' at line 1: SELECT `posts`.* FROM `posts` WHERE ((`posts`.`featured` = 1 OR `posts`.`author_id` = 5)) ORDER BY (ln( 1 + posts.likes_count) + (EXTRACT(EPOCH FROM posts.created_at) - 1327654606)/9000) desc LIMIT 15
The StreamsController#front_page are:
def front_page
stream_responder do
#stream = Stream::FrontPage.new(current_user, params[:offset])
#stream_json = PostPresenter.collection_json(#stream.stream_posts, current_user, lite?: true, include_root: false)
end
end
And PostPresenter
require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'template_picker')
class PostPresenter
include ActionView::Helpers::TextHelper
attr_accessor :post, :current_user
def initialize(post, current_user=nil)
#post = post
#current_user = current_user
#person = #current_user.try(:person)
end
def self.collection_json(collection, current_user, opts={})
collection.includes(:author => :profile).map {|post| self.new(post, current_user).as_json(opts)}
end
def as_json(options={})
{
:id => #post.id,
:guid => #post.guid,
:text => #post.raw_message,
:plain_text => #post.plain_text,
:public => #post.public,
:featured => #post.featured,
:created_at => #post.created_at,
:staff_picked_at => #post.staff_picked_at,
:interacted_at => #post.interacted_at,
:tags => #post.tags.as_json,
:tag_list => #post.tags.map(&:name).join(", "),
:post_type => #post.post_type,
:image_url => #post.image_url,
:object_url => #post.object_url,
:favorite => #post.favorite,
:nsfw => #post.nsfw,
:author => PersonPresenter.new(#post.author, current_user),
:o_embed_cache => #post.o_embed_cache.try(:as_api_response, :backbone),
:mentioned_people => [],
:photos => #post.photos.map {|p| p.as_api_response(:backbone)},
:frame_name => #post.frame_name || template_name,
:parent => (options.fetch(:include_root, true) ? parent(options) : nil),
:title => title,
:next_post => next_post_path,
:previous_post => previous_post_path,
:screenshot_url => #post.screenshot_url,
:screenshot_width => #post.screenshot_width,
:screenshot_height => #post.screenshot_height,
:show_screenshot => self.show_screenshot?,
:has_gif => self.has_gif?,
:conversation_id => #post.conversation_id,
:interactions => options.fetch(:lite?, false) ? lite_interactions : heavy_interactions,
:original => #post.original?
}
end
def next_post_path
Rails.application.routes.url_helpers.next_post_path(#post)
end
def previous_post_path
Rails.application.routes.url_helpers.previous_post_path(#post)
end
def heavy_interactions
PostInteractionPresenter.new(#post, current_user).as_json
end
def lite_interactions
PostInteractionPresenter::Lite.new(#post, current_user).as_json
end
def title
#post.text.present? ? truncate(#post.plain_text, :length => 118) : I18n.translate('posts.presenter.title', :name => #post.author.name)
end
def template_name #kill me, lol, I should be client side
#template_name ||= TemplatePicker.new(#post).template_name
end
def parent(opts={})
PostPresenter.new(#post.parent, current_user).as_json({:include_root => false}.merge(opts)) if #post.respond_to?(:parent) && #post.parent.present?
end
def show_screenshot?
#post.screenshot_url.present?
end
def has_gif?
return false unless #post.photos.present?
return 'gif' if #post.photos.detect{ |p| p.url && p.url.match(".gif") }.present?
end
protected
def person
#current_user.person
end
def user_signed_in?
#current_user.present?
end
end
I dont know where am i do wrong..? badly need help on this
You're closing an unopened parenthesis in the query.
'EPOCH FROM posts.created_at) ...'