mirror of
https://github.com/LaCasemate/fab-manager.git
synced 2024-12-11 22:24:21 +01:00
420 lines
15 KiB
Ruby
420 lines
15 KiB
Ruby
class Reservation < ActiveRecord::Base
|
|
include NotifyWith::NotificationAttachedObject
|
|
|
|
belongs_to :user
|
|
has_many :slots, dependent: :destroy
|
|
accepts_nested_attributes_for :slots, allow_destroy: true
|
|
belongs_to :reservable, polymorphic: true
|
|
|
|
has_many :tickets
|
|
accepts_nested_attributes_for :tickets, allow_destroy: false
|
|
|
|
has_one :invoice, -> {where(type: nil)}, as: :invoiced, dependent: :destroy
|
|
|
|
validates_presence_of :reservable_id, :reservable_type
|
|
validate :machine_not_already_reserved, if: -> { self.reservable.is_a?(Machine) }
|
|
validate :training_not_fully_reserved, if: -> { self.reservable.is_a?(Training) }
|
|
|
|
attr_accessor :card_token, :plan_id, :subscription
|
|
|
|
after_commit :notify_member_create_reservation, on: :create
|
|
after_commit :notify_admin_member_create_reservation, on: :create
|
|
after_save :update_event_nb_free_places, if: Proc.new { |reservation| reservation.reservable_type == 'Event' }
|
|
after_create :debit_user_wallet
|
|
|
|
##
|
|
# Generate an array of {Stripe::InvoiceItem} with the elements in the current reservation, price included.
|
|
# The training/machine price is depending of the member's group, subscription and credits already used
|
|
# @param on_site {Boolean} true if an admin triggered the call
|
|
# @param coupon_code {String} pass a valid code to appy a coupon
|
|
##
|
|
def generate_invoice_items(on_site = false, coupon_code = nil)
|
|
|
|
# returning array
|
|
invoice_items = []
|
|
|
|
# prepare the plan
|
|
if user.subscribed_plan
|
|
plan = user.subscribed_plan
|
|
new_plan_being_bought = false
|
|
elsif plan_id
|
|
plan = Plan.find(plan_id)
|
|
new_plan_being_bought = true
|
|
else
|
|
plan = nil
|
|
end
|
|
|
|
|
|
case reservable
|
|
|
|
# === Machine reservation ===
|
|
when Machine
|
|
base_amount = reservable.prices.find_by(group_id: user.group_id, plan_id: plan.try(:id)).amount
|
|
users_credits_manager = UsersCredits::Manager.new(reservation: self, plan: plan)
|
|
|
|
slots.each_with_index do |slot, index|
|
|
description = reservable.name + " #{I18n.l slot.start_at, format: :long} - #{I18n.l slot.end_at, format: :hour_minute}"
|
|
|
|
ii_amount = base_amount # ii_amount default to base_amount
|
|
|
|
if users_credits_manager.will_use_credits?
|
|
ii_amount = (index < users_credits_manager.free_hours_count) ? 0 : base_amount
|
|
end
|
|
|
|
ii_amount = 0 if slot.offered and on_site # if it's a local payment and slot is offered free
|
|
|
|
unless on_site # if it's local payment then do not create Stripe::InvoiceItem
|
|
ii = Stripe::InvoiceItem.create(
|
|
customer: user.stp_customer_id,
|
|
amount: ii_amount,
|
|
currency: Rails.application.secrets.stripe_currency,
|
|
description: description
|
|
)
|
|
invoice_items << ii
|
|
end
|
|
self.invoice.invoice_items.push InvoiceItem.new(amount: ii_amount, stp_invoice_item_id: (ii.id if ii), description: description)
|
|
end
|
|
|
|
|
|
# === Training reservation ===
|
|
when Training
|
|
base_amount = reservable.amount_by_group(user.group_id).amount
|
|
|
|
# be careful, variable plan can be the user's plan OR the plan user is currently purchasing
|
|
users_credits_manager = UsersCredits::Manager.new(reservation: self, plan: plan)
|
|
base_amount = 0 if users_credits_manager.will_use_credits?
|
|
|
|
slots.each do |slot|
|
|
description = reservable.name + " #{I18n.l slot.start_at, format: :long} - #{I18n.l slot.end_at, format: :hour_minute}"
|
|
ii_amount = base_amount
|
|
ii_amount = 0 if (slot.offered and on_site)
|
|
unless on_site
|
|
ii = Stripe::InvoiceItem.create(
|
|
customer: user.stp_customer_id,
|
|
amount: ii_amount,
|
|
currency: Rails.application.secrets.stripe_currency,
|
|
description: description
|
|
)
|
|
invoice_items << ii
|
|
end
|
|
self.invoice.invoice_items.push InvoiceItem.new(amount: ii_amount, stp_invoice_item_id: (ii.id if ii), description: description)
|
|
end
|
|
|
|
# === Event reservation ===
|
|
when Event
|
|
amount = reservable.amount * nb_reserve_places
|
|
tickets.each do |ticket|
|
|
amount += ticket.booked * ticket.event_price_category.amount
|
|
end
|
|
slots.each do |slot|
|
|
description = reservable.name + " #{I18n.l slot.start_at, format: :long} - #{I18n.l slot.end_at, format: :hour_minute}"
|
|
ii_amount = amount
|
|
ii_amount = 0 if (slot.offered and on_site)
|
|
unless on_site
|
|
ii = Stripe::InvoiceItem.create(
|
|
customer: user.stp_customer_id,
|
|
amount: ii_amount,
|
|
currency: Rails.application.secrets.stripe_currency,
|
|
description: description
|
|
)
|
|
invoice_items << ii
|
|
end
|
|
self.invoice.invoice_items.push InvoiceItem.new(amount: ii_amount, stp_invoice_item_id: (ii.id if ii), description: description)
|
|
end
|
|
|
|
# === Unknown reservation type ===
|
|
else
|
|
raise NotImplementedError
|
|
|
|
end
|
|
|
|
# === Coupon ===
|
|
unless coupon_code.nil?
|
|
cp = Coupon.find_by_code(coupon_code)
|
|
total = invoice.invoice_items.map(&:amount).map(&:to_i).reduce(:+)
|
|
unless on_site
|
|
invoice_items << Stripe::InvoiceItem.create(
|
|
customer: user.stp_customer_id,
|
|
amount: -(total * cp.percent_off / 100).to_i,
|
|
currency: Rails.application.secrets.stripe_currency,
|
|
description: "coupon #{cp.code}"
|
|
)
|
|
end
|
|
end
|
|
|
|
@wallet_amount_debit = get_wallet_amount_debit
|
|
if @wallet_amount_debit != 0 and !on_site
|
|
invoice_items << Stripe::InvoiceItem.create(
|
|
customer: user.stp_customer_id,
|
|
amount: -@wallet_amount_debit,
|
|
currency: Rails.application.secrets.stripe_currency,
|
|
description: "wallet -#{@wallet_amount_debit / 100.0}"
|
|
)
|
|
end
|
|
|
|
# let's return the resulting array of items
|
|
invoice_items
|
|
end
|
|
|
|
def save_with_payment(coupon_code = nil)
|
|
build_invoice(user: user)
|
|
invoice_items = generate_invoice_items(false, coupon_code)
|
|
if valid?
|
|
# TODO: refactoring
|
|
customer = Stripe::Customer.retrieve(user.stp_customer_id)
|
|
if plan_id
|
|
self.subscription = Subscription.find_or_initialize_by(user_id: user.id)
|
|
self.subscription.attributes = {plan_id: plan_id, user_id: user.id, card_token: card_token, expired_at: nil}
|
|
if subscription.save_with_payment(false, coupon_code)
|
|
self.stp_invoice_id = invoice_items.first.refresh.invoice
|
|
self.invoice.stp_invoice_id = invoice_items.first.refresh.invoice
|
|
self.invoice.invoice_items.push InvoiceItem.new(amount: subscription.plan.amount, stp_invoice_item_id: subscription.stp_subscription_id, description: subscription.plan.name, subscription_id: subscription.id)
|
|
set_total_and_coupon(coupon_code)
|
|
save!
|
|
#
|
|
# IMPORTANT NOTE: here, we don't have to create a stripe::invoice and pay it
|
|
# because subscription.create (in subscription.rb) will pay all waiting stripe invoice items
|
|
#
|
|
else
|
|
# error handling
|
|
invoice_items.each(&:delete)
|
|
errors[:card] << subscription.errors[:card].join
|
|
if subscription.errors[:payment]
|
|
errors[:payment] << subscription.errors[:payment].join
|
|
end
|
|
return false
|
|
end
|
|
|
|
else
|
|
begin
|
|
if invoice_items.map(&:amount).map(&:to_i).reduce(:+) > 0
|
|
card = customer.sources.create(card: card_token)
|
|
if customer.default_source.present?
|
|
customer.default_source = card.id
|
|
customer.save
|
|
end
|
|
end
|
|
#
|
|
# IMPORTANT NOTE: here, we have to create an invoice manually and pay it to pay all waiting stripe invoice items
|
|
#
|
|
stp_invoice = Stripe::Invoice.create(
|
|
customer: user.stp_customer_id,
|
|
)
|
|
stp_invoice.pay
|
|
card.delete if card
|
|
self.stp_invoice_id = stp_invoice.id
|
|
self.invoice.stp_invoice_id = stp_invoice.id
|
|
set_total_and_coupon(coupon_code)
|
|
save!
|
|
rescue Stripe::CardError => card_error
|
|
clear_payment_info(card, stp_invoice, invoice_items)
|
|
logger.info card_error
|
|
errors[:card] << card_error.message
|
|
return false
|
|
rescue Stripe::InvalidRequestError => e
|
|
# Invalid parameters were supplied to Stripe's API
|
|
clear_payment_info(card, stp_invoice, invoice_items)
|
|
logger.error e
|
|
errors[:payment] << e.message
|
|
return false
|
|
rescue Stripe::AuthenticationError => e
|
|
# Authentication with Stripe's API failed
|
|
# (maybe you changed API keys recently)
|
|
clear_payment_info(card, stp_invoice, invoice_items)
|
|
logger.error e
|
|
errors[:payment] << e.message
|
|
return false
|
|
rescue Stripe::APIConnectionError => e
|
|
# Network communication with Stripe failed
|
|
clear_payment_info(card, stp_invoice, invoice_items)
|
|
logger.error e
|
|
errors[:payment] << e.message
|
|
return false
|
|
rescue Stripe::StripeError => e
|
|
# Display a very generic error to the user, and maybe send
|
|
# yourself an email
|
|
clear_payment_info(card, stp_invoice, invoice_items)
|
|
logger.error e
|
|
errors[:payment] << e.message
|
|
return false
|
|
rescue => e
|
|
# Something else happened, completely unrelated to Stripe
|
|
clear_payment_info(card, stp_invoice, invoice_items)
|
|
logger.error e
|
|
errors[:payment] << e.message
|
|
return false
|
|
end
|
|
end
|
|
|
|
UsersCredits::Manager.new(reservation: self).update_credits
|
|
true
|
|
end
|
|
end
|
|
|
|
def clear_payment_info(card, invoice, invoice_items)
|
|
begin
|
|
card.delete if card
|
|
if invoice
|
|
invoice.closed = true
|
|
invoice.save
|
|
end
|
|
if invoice_items.size > 0
|
|
invoice_items.each(&:delete)
|
|
end
|
|
rescue Stripe::InvalidRequestError => e
|
|
logger.error e
|
|
rescue Stripe::AuthenticationError => e
|
|
logger.error e
|
|
rescue Stripe::APIConnectionError => e
|
|
logger.error e
|
|
rescue Stripe::StripeError => e
|
|
logger.error e
|
|
rescue => e
|
|
logger.error e
|
|
end
|
|
end
|
|
|
|
|
|
def save_with_local_payment(coupon_code = nil)
|
|
if user.invoicing_disabled?
|
|
if valid?
|
|
|
|
### generate invoice only for calcul price, TODO refactor!!
|
|
build_invoice(user: user)
|
|
generate_invoice_items(true, coupon_code)
|
|
@wallet_amount_debit = get_wallet_amount_debit
|
|
self.invoice = nil
|
|
###
|
|
|
|
save!
|
|
UsersCredits::Manager.new(reservation: self).update_credits
|
|
return true
|
|
end
|
|
else
|
|
build_invoice(user: user)
|
|
generate_invoice_items(true, coupon_code)
|
|
end
|
|
|
|
if valid?
|
|
if plan_id
|
|
self.subscription = Subscription.find_or_initialize_by(user_id: user.id)
|
|
self.subscription.attributes = {plan_id: plan_id, user_id: user.id, expired_at: nil}
|
|
if subscription.save_with_local_payment(false)
|
|
self.invoice.invoice_items.push InvoiceItem.new(amount: subscription.plan.amount, description: subscription.plan.name, subscription_id: subscription.id)
|
|
set_total_and_coupon(coupon_code)
|
|
save!
|
|
else
|
|
errors[:card] << subscription.errors[:card].join
|
|
return false
|
|
end
|
|
else
|
|
set_total_and_coupon(coupon_code)
|
|
save!
|
|
end
|
|
|
|
UsersCredits::Manager.new(reservation: self).update_credits
|
|
return true
|
|
end
|
|
end
|
|
|
|
def total_booked_seats
|
|
total = nb_reserve_places
|
|
if tickets.count > 0
|
|
total += tickets.map(&:booked).map(&:to_i).reduce(:+)
|
|
end
|
|
total
|
|
end
|
|
|
|
private
|
|
def machine_not_already_reserved
|
|
already_reserved = false
|
|
self.slots.each do |slot|
|
|
same_hour_slots = Slot.joins(:reservation).where(
|
|
reservations: { reservable_type: self.reservable_type,
|
|
reservable_id: self.reservable_id
|
|
},
|
|
start_at: slot.start_at,
|
|
end_at: slot.end_at,
|
|
availability_id: slot.availability_id,
|
|
canceled_at: nil)
|
|
if same_hour_slots.any?
|
|
already_reserved = true
|
|
break
|
|
end
|
|
end
|
|
errors.add(:machine, "already reserved") if already_reserved
|
|
end
|
|
|
|
def training_not_fully_reserved
|
|
slot = self.slots.first
|
|
errors.add(:training, "already fully reserved") if Availability.find(slot.availability_id).is_completed
|
|
end
|
|
|
|
private
|
|
def notify_member_create_reservation
|
|
NotificationCenter.call type: 'notify_member_create_reservation',
|
|
receiver: user,
|
|
attached_object: self
|
|
end
|
|
|
|
def notify_admin_member_create_reservation
|
|
NotificationCenter.call type: 'notify_admin_member_create_reservation',
|
|
receiver: User.admins,
|
|
attached_object: self
|
|
end
|
|
|
|
def update_event_nb_free_places
|
|
if reservable_id_was.blank?
|
|
# simple reservation creation, we subtract the number of booked seats from the previous number
|
|
nb_free_places = reservable.nb_free_places - total_booked_seats
|
|
else
|
|
# reservation moved from another date (for recurring events)
|
|
seats = total_booked_seats
|
|
|
|
reservable_was = Event.find(reservable_id_was)
|
|
nb_free_places = reservable_was.nb_free_places + seats
|
|
reservable_was.update_columns(nb_free_places: nb_free_places)
|
|
nb_free_places = reservable.nb_free_places - seats
|
|
end
|
|
reservable.update_columns(nb_free_places: nb_free_places)
|
|
end
|
|
|
|
def get_wallet_amount_debit
|
|
total = (self.invoice.invoice_items.map(&:amount).map(&:to_i).reduce(:+) or 0)
|
|
if plan_id.present?
|
|
plan = Plan.find(plan_id)
|
|
total += plan.amount
|
|
end
|
|
wallet_amount = (user.wallet.amount * 100).to_i
|
|
|
|
wallet_amount >= total ? total : wallet_amount
|
|
end
|
|
|
|
def debit_user_wallet
|
|
if @wallet_amount_debit.present? and @wallet_amount_debit != 0
|
|
amount = @wallet_amount_debit / 100.0
|
|
wallet_transaction = WalletService.new(user: user, wallet: user.wallet).debit(amount, self)
|
|
if !user.invoicing_disabled? and wallet_transaction
|
|
self.invoice.update_columns(wallet_amount: @wallet_amount_debit, wallet_transaction_id: wallet_transaction.id)
|
|
end
|
|
end
|
|
end
|
|
|
|
##
|
|
# Set the total price to the reservation's invoice, summing its whole items.
|
|
# Additionally a coupon may be applied to this invoice to make a discount on the total price
|
|
# @param [coupon_code] {String} optional coupon code to apply to the invoice
|
|
##
|
|
def set_total_and_coupon(coupon_code = nil)
|
|
total = invoice.invoice_items.map(&:amount).map(&:to_i).reduce(:+)
|
|
|
|
unless coupon_code.nil?
|
|
cp = Coupon.find_by_code(coupon_code)
|
|
total = total - (total * cp.percent_off / 100.0)
|
|
self.invoice.coupon_id = cp.id
|
|
end
|
|
|
|
self.invoice.total = total
|
|
end
|
|
end
|