spree_cm_commissioner 2.5.1.pre.pre5 → 2.5.1

data/app/services/spree_cm_commissioner/route_metrics/increase_trip_count.rb

@@ -1,31 +0,0 @@
-module SpreeCmCommissioner
-  module RouteMetrics
-    class IncreaseTripCount
-      prepend ::Spree::ServiceModule::Base
-
-      def call(trip:)
-        return failure(nil, 'Trip not found') unless trip
-
-        route_metric = find_or_create_route_metric(trip)
-
-        route_metric.with_lock do
-          route_metric.update!(trip_count: route_metric.trip_count + 1)
-        end
-
-        success(trip: trip)
-      rescue StandardError => e
-        failure(nil, e.message)
-      end
-
-      private
-
-      def find_or_create_route_metric(trip)
-        SpreeCmCommissioner::RouteMetric.find_or_create_by!(
-          origin_place_id: trip.origin_place_id,
-          destination_place_id: trip.destination_place_id,
-          route_type: trip.route_type
-        )
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/routes/create.rb

@@ -1,51 +0,0 @@
-module SpreeCmCommissioner
-  module Routes
-    class Create
-      prepend ::Spree::ServiceModule::Base
-
-      # @param vendor [Spree::Vendor]
-      # @param route_params [Hash]
-      # @param route_stops [SpreeCmCommissioner::Transit::RouteStopCollection]
-      def call(vendor:, route_params:, route_stops:)
-        # vendor_id, tenant_id, origin_place_id, destination_place_id are excluded and set automatically.
-        attrs = ::Spree::PermittedAttributes.route_attributes
-                                            .index_with { |attr_key| route_params[attr_key] }
-                                            .except(:vendor_id, :tenant_id, :route_stops, :origin_place_id, :destination_place_id)
-                                            .compact
-
-        return failure(nil, 'Route stops are required') if route_stops.length < 2
-
-        origin_place = find_place_for(route_stops, route_stops.first)
-        destination_place = find_place_for(route_stops, route_stops.last)
-
-        return failure(nil, 'Origin or destination place could not be determined') if origin_place.nil? || destination_place.nil?
-        return failure(nil, 'Route with origin & destination already exists') if vendor.routes.exists?(
-          origin_place_id: origin_place.id,
-          destination_place_id: destination_place.id
-        )
-
-        attrs = attrs.merge(
-          tenant_id: vendor.tenant_id,
-          route_name: attrs[:route_name] || "#{origin_place.name} -> #{destination_place.name}",
-          origin_place_id: origin_place.id,
-          destination_place_id: destination_place.id,
-          route_stops: route_stops
-        )
-
-        route = vendor.routes.new(attrs)
-        if route.save
-          success(route: route)
-        else
-          failure(route.errors)
-        end
-      end
-
-      def find_place_for(route_stops, route_stop)
-        return nil if route_stop.nil?
-
-        @locations ||= SpreeCmCommissioner::VendorPlace.where(id: route_stops.map(&:location_id).uniq).index_by(&:id)
-        @locations[route_stop.location_id]&.place
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/routes/update.rb

@@ -1,25 +0,0 @@
-module SpreeCmCommissioner
-  module Routes
-    class Update
-      prepend ::Spree::ServiceModule::Base
-
-      def call(vendor:, route:, route_params:)
-        # vendor_id, tenant_id, origin_place_id, destination_place_id are excluded and set automatically.
-        # route_stops is not updateable.
-        attrs = ::Spree::PermittedAttributes.route_attributes
-                                            .index_with { |attr_key| route_params[attr_key] }
-                                            .except(:vendor_id, :tenant_id, :route_stops, :origin_place_id, :destination_place_id)
-                                            .compact
-
-        route = vendor.routes.find_by(id: route.id)
-        return failure(nil, :route_not_found) if route.nil?
-
-        if route.update(attrs)
-          success(route: route)
-        else
-          failure(route.errors)
-        end
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/trips/create_single_leg.rb

@@ -1,128 +0,0 @@
-module SpreeCmCommissioner
-  module Trips
-    # Service class responsible for creating a single-leg trip in the booking system.
-    # Orchestrates the creation of product variant, trip record, stops, calendar, and inventory.
-    class CreateSingleLeg
-      prepend Spree::ServiceModule::Base
-
-      # Main service method that validates the trip form and orchestrates creation.
-      # Creates variant, trip, calendar, and inventory within a database transaction.
-      # Returns success with created objects or failure with error message on exceptions.
-      def call(vendor:, trip_form:)
-        return failure(nil, trip_form.errors.full_messages.to_sentence) unless trip_form.valid_data?
-
-        ApplicationRecord.transaction do
-          variant = create_variant!(vendor, trip_form)
-          trip = create_trip!(vendor, trip_form, variant)
-          calendar = setup_calendar!(variant.product, trip_form.service_calendar)
-          generate_inventory!(variant)
-
-          success(trip: trip, variant: variant, calendar: calendar)
-        rescue StandardError => e
-          CmAppLogger.error(
-            label: 'SpreeCmCommissioner::Trips::CreateSingleLeg#call',
-            data: {
-              error_class: e.class.name,
-              error_message: e.message
-            }
-          )
-          failure(nil, e.message)
-        end
-      end
-
-      private
-
-      # Creates a product variant for the trip using the vehicle type's seat capacity.
-      def create_variant!(vendor, trip_form)
-        first_stop = trip_form.trip_stops.first
-        vehicle_type = SpreeCmCommissioner::VehicleType.find(first_stop.vehicle_type_id)
-        capacity = vehicle_type.number_of_seats.to_i
-
-        raise StandardError, 'Vehicle type must be selected' if vehicle_type.blank?
-        raise StandardError, 'Vehicle type seat capacity must be greater than 0' if capacity <= 0
-
-        result = SpreeCmCommissioner::Trips::Variants::Create.call(
-          vendor: vendor,
-          trip_form: trip_form,
-          price: trip_form.price || 0.0,
-          capacity: capacity
-        )
-
-        raise StandardError, result.error unless result.success?
-
-        result.value[:variant]
-      end
-
-      # Creates the main trip record with details extracted from the trip form.
-      # Associates the trip with vendor, product, vehicle, route, and time.
-      def create_trip!(vendor, trip_form, variant)
-        first_stop = trip_form.trip_stops.first
-        last_stop  = trip_form.trip_stops.last
-
-        locations = vendor.locations.where(id: trip_form.trip_stops.map(&:location_id)).index_by(&:id)
-
-        # vendor_places are either stops or branches
-        vendor_places = SpreeCmCommissioner::VendorPlace
-                        .where(id: trip_form.trip_stops.map(&:stop_id), vendor: vendor)
-                        .index_by(&:id)
-
-        trip = vendor.trips.create!(
-          product: variant.product,
-          vehicle_type: SpreeCmCommissioner::VehicleType.find_by(id: first_stop.vehicle_type_id),
-          vehicle: SpreeCmCommissioner::Vehicle.find_by(id: first_stop.vehicle_id),
-          origin_place_id: locations[first_stop.location_id.to_i].place_id,
-          destination_place_id: locations[last_stop.location_id.to_i].place_id,
-          route: vendor.routes.find(trip_form.route_id),
-          departure_time: first_stop.departure_time,
-          duration: trip_form.total_duration_seconds,
-          allow_booking: trip_form.allow_booking,
-          allow_seat_selection: trip_form.allow_seat_selection,
-          route_type: trip_form.route_type || vendor.routes.find(trip_form.route_id)&.route_type
-        )
-
-        create_trip_stops(trip, trip_form, locations, vendor_places)
-        trip
-      end
-
-      # Creates individual trip stops based on the trip form stops.
-      # Each stop includes arrival/departure times and boarding/drop-off permissions.
-      def create_trip_stops(trip, trip_form, locations, vendor_places)
-        previous_departure = nil
-        Array(trip_form.trip_stops).each do |ts|
-          arrival_time = previous_departure || ts.departure_time
-          trip.trip_stops.create!(
-            stop_place: vendor_places[ts.stop_id.to_i].place,
-            location_place: locations[ts.location_id.to_i].place,
-            allow_boarding: ts.allow_boarding?,
-            allow_drop_off: ts.allow_drop_off?,
-            arrival_time: arrival_time,
-            departure_time: ts.departure_time
-          )
-
-          previous_departure = ts.departure_time
-        end
-      end
-
-      # Sets up the service calendar for the trip, defining operational dates, weekdays, and exceptions.
-      def setup_calendar!(product, calendar_form)
-        res = SpreeCmCommissioner::Trips::ServiceCalendars::CreateOrUpdate.call(
-          calendarable: product,
-          name: calendar_form.name,
-          start_date: calendar_form.start_date,
-          end_date: calendar_form.end_date,
-          weekdays: calendar_form.weekdays,
-          exception_rules: calendar_form.exception_rules || []
-        )
-
-        raise StandardError, res.error unless res.success?
-
-        res.value[:calendar]
-      end
-
-      # Triggers asynchronous generation of permanent inventory items for the variant.
-      def generate_inventory!(variant)
-        SpreeCmCommissioner::Stock::PermanentInventoryItemsGeneratorJob.perform_later(variant_ids: [variant[:id]])
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/trips/service_calendars/create_or_update.rb

@@ -1,54 +0,0 @@
-module SpreeCmCommissioner
-  module Trips
-    module ServiceCalendars
-      # Service to create or update a service calendar for a calendarable entity.
-      class CreateOrUpdate
-        prepend ::Spree::ServiceModule::Base
-
-        def call(calendarable:, name:, start_date:, end_date:, weekdays:, exception_rules: []) # rubocop:disable Metrics/ParameterLists
-          return failure(nil, 'calendarable must be present') if calendarable.blank?
-          return failure(nil, 'name must be present') if name.blank?
-          return failure(nil, 'start_date must be present') if start_date.blank?
-          return failure(nil, 'end_date must be present') if end_date.blank?
-          return failure(nil, 'weekdays must be present') if weekdays.blank?
-
-          ApplicationRecord.transaction do
-            calendar = create_or_update_calendar(calendarable, name, start_date, end_date, weekdays, exception_rules)
-            success(calendar: calendar)
-          end
-        rescue StandardError => e
-          CmAppLogger.error(
-            label: 'SpreeCmCommissioner::Trips::ServiceCalendars::CreateOrUpdate#call',
-            data: {
-              error_class: e.class.name,
-              error_message: e.message
-            }
-          )
-          failure(nil, 'Failed to create service calendar')
-        end
-
-        private
-
-        # Create or update calendar
-        def create_or_update_calendar(calendarable, name, start_date, end_date, weekdays, exception_rules) # rubocop:disable Metrics/ParameterLists
-          calendar = calendarable.service_calendar || calendarable.build_service_calendar
-
-          calendar.assign_attributes(
-            name: name,
-            start_date: start_date,
-            end_date: end_date,
-            exception_rules: exception_rules
-          )
-
-          # Set weekday attributes
-          weekdays.each do |day, enabled|
-            calendar.send("#{day}=", enabled)
-          end
-
-          calendar.save!
-          calendar
-        end
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/trips/update_single_leg.rb

@@ -1,88 +0,0 @@
-module SpreeCmCommissioner
-  module Trips
-    # Service class responsible for updating an existing single-leg trip.
-    # Handles updates to trip, product, variant, stops, and calendar in the booking system.
-    class UpdateSingleLeg
-      prepend Spree::ServiceModule::Base
-
-      # Main service method that orchestrates trip updates within a database transaction.
-      # Updates trip/product, variant if price provided, stops, and calendar conditionally.
-      # Returns success with updated objects or failure with error message.
-      def call(trip:, trip_form:)
-        ApplicationRecord.transaction do
-          update_trip_and_product(trip, trip_form)
-          update_variant(trip, trip_form) if trip_form.price.present?
-          update_trip_stops(trip, trip_form)
-          calendar = update_calendar(trip.product, trip_form.service_calendar) if trip_form.service_calendar.present?
-
-          success(trip: trip, variant: trip.product.variants.first, calendar: calendar)
-        rescue StandardError => e
-          CmAppLogger.error(
-            label: 'SpreeCmCommissioner::Trips::UpdateSingleLeg#call',
-            data: {
-              error_class: e.class.name,
-              error_message: e.message
-            }
-          )
-          failure(nil, 'Failed to update trip')
-        end
-      end
-
-      private
-
-      # Updates the trip record and associated product with attributes from the form.
-      def update_trip_and_product(trip, trip_form)
-        trip.update!(trip_attrs(trip_form))
-        trip.product.update!(product_attrs(trip_form))
-      end
-
-      # Updates the variant's price if a new price is provided in the form.
-      def update_variant(trip, trip_form)
-        variant = trip.product.variants.where.not(id: trip.product.master.id).first
-        return unless variant
-
-        variant.update!(price: trip_form.price)
-        trip.product.update!(price: trip_form.price)
-      end
-
-      # Iterates through stops and applies updates only if attributes are present.
-      def update_trip_stops(trip, trip_form)
-        trip.trip_stops.each_with_index do |stop, idx|
-          ts_form = trip_form.trip_stops[idx]
-          next unless ts_form
-
-          updates = {
-            allow_boarding: ts_form.allow_boarding?,
-            allow_drop_off: ts_form.allow_drop_off
-          }.compact
-
-          stop.update!(updates) if updates.any?
-        end
-      end
-
-      # Updates or creates the service calendar for the product using calendar form data.
-      def update_calendar(product, calendar_form)
-        result = SpreeCmCommissioner::Trips::ServiceCalendars::CreateOrUpdate.call(
-          calendarable: product,
-          name: calendar_form.name,
-          start_date: calendar_form.start_date,
-          end_date: calendar_form.end_date,
-          weekdays: calendar_form.weekdays,
-          exception_rules: calendar_form.exception_rules || []
-        )
-
-        raise result.error unless result.success?
-
-        result.value[:calendar]
-      end
-
-      def trip_attrs(form)
-        { allow_booking: form.allow_booking, allow_seat_selection: form.allow_seat_selection }.compact
-      end
-
-      def product_attrs(form)
-        { name: form.name, short_name: form.short_name }.compact
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/trips/variants/create.rb

@@ -1,103 +0,0 @@
-module SpreeCmCommissioner
-  module Trips
-    module Variants
-      # Service class responsible for creating product and variant for a trip.
-      # Handles validations, product creation with options, variant pricing, and stock setup.
-      class Create
-        prepend ::Spree::ServiceModule::Base
-
-        # Main method that validates inputs and creates product, options, variant, and stock in transaction.
-        # Returns success with product and variant or failure with error message.
-        def call(vendor:, trip_form:, price:, capacity:)
-          return failure(nil, 'vendor must be present') if vendor.blank?
-          return failure(nil, 'trip_form must be present') if trip_form.blank?
-          return failure(nil, 'price must be present') if price.blank?
-          return failure(nil, 'capacity must be present') if capacity.blank?
-          return failure(nil, 'capacity must be greater than 0') if capacity <= 0
-
-          ApplicationRecord.transaction do
-            product = create_product!(vendor, trip_form)
-            option_values = setup_option_values!(product)
-            variant = create_variant!(product, price, option_values)
-
-            create_stock_item!(variant, capacity)
-
-            success(product: product, variant: variant)
-          end
-        rescue StandardError => e
-          CmAppLogger.error(
-            label: 'SpreeCmCommissioner::Trips::Variants::Create#call',
-            data: {
-              error_class: e.class.name,
-              error_message: e.message
-            }
-          )
-          failure(nil, e.message)
-        end
-
-        private
-
-        # Creates a transit product with name based on stops, assigns vendor, type, and options.
-        # Includes seat-type option type and default store association.
-        def create_product!(vendor, trip_form)
-          vendor_stops = branches(vendor, trip_form)
-          first_stop = vendor_stops[trip_form.trip_stops.first.stop_id]
-          last_stop = vendor_stops[trip_form.trip_stops.last.stop_id]
-
-          Spree::Product.create!(
-            name: trip_form.name.presence || "#{first_stop.id} - #{last_stop.id}",
-            short_name: trip_form.short_name,
-            vendor: vendor,
-            product_type: 'transit',
-            status: 'active',
-            available_on: Time.current,
-            price: trip_form.price,
-            shipping_category: Spree::ShippingCategory.find_or_create_by!(name: 'Default'),
-            option_types: [Spree::OptionType.find_by(name: 'seat-type')].compact,
-            stores: [Spree::Store.default].compact
-          )
-        end
-
-        # Retrieves and indexes stops from the vendor for the trip form's stop IDs.
-        def branches(vendor, trip_form)
-          vendor.branches.where(id: trip_form.trip_stops.map(&:stop_id)).index_by(&:id)
-        end
-
-        # Sets up or finds the seat-type option type and creates normal option value.
-        # Associates the option type with the product if not already present.
-        def setup_option_values!(product)
-          option_type = Spree::OptionType.find_or_create_by!(
-            name: 'seat-type',
-            presentation: 'Seat Type'
-          )
-
-          product.option_types << option_type unless product.option_types.include?(option_type)
-
-          option_value = option_type.option_values.find_or_create_by_name!(option_type, 'Normal')
-
-          [option_value]
-        end
-
-        # Creates a product variant with the given price and associated option values.
-        # Saves the variant to the database.
-        def create_variant!(product, price, option_values)
-          variant = product.variants.new(price: price)
-          variant.option_values = option_values
-          variant.save!
-          variant
-        end
-
-        # Creates a stock item for the variant with the specified capacity.
-        # Uses stock movement creator to initialize inventory.
-        def create_stock_item!(variant, capacity)
-          result = SpreeCmCommissioner::Stock::StockMovementCreator.call(
-            variant_id: variant.id,
-            current_store: variant.product.stores.first,
-            stock_movement_params: { quantity: capacity }
-          )
-          result.stock_item
-        end
-      end
-    end
-  end
-end

data/db/migrate/20251224033103_migrate_cm_routes_to_cm_route_metrics.rb

@@ -1,17 +0,0 @@
-class MigrateCmRoutesToCmRouteMetrics < ActiveRecord::Migration[7.0]
-  def change
-    # 1. Rename cm_routes which we use to track order, trip count to cm_route_metrics instead.
-    remove_index :cm_routes, [:origin_place_id, :destination_place_id] if index_exists?(:cm_routes, [:origin_place_id, :destination_place_id])
-    rename_table :cm_routes, :cm_route_metrics unless table_exists?(:cm_route_metrics)
-    add_column :cm_route_metrics, :route_type, :integer, default: 0, null: false unless column_exists?(:cm_route_metrics, :route_type)
-
-    # 2. Drop the old index before renaming table to avoid index name length issues & re-add the index with a shorter name
-    unless index_exists?(:cm_route_metrics, [:route_type, :origin_place_id, :destination_place_id], name: 'index_cm_route_metrics_on_origin_dest')
-      add_index :cm_route_metrics, [:route_type, :origin_place_id, :destination_place_id], unique: true, name: 'index_cm_route_metrics_on_origin_dest'
-    end
-
-    # 3. Remove old route_id column from trips.
-    # it has route_metrics value, and trip don't need to have association with metric directly.
-    remove_column :cm_trips, :route_id if column_exists?(:cm_trips, :route_id)
-  end
-end

data/db/migrate/20251224033910_migrate_cm_vendor_routes_to_cm_routes.rb

@@ -1,30 +0,0 @@
-class MigrateCmVendorRoutesToCmRoutes < ActiveRecord::Migration[7.0]
-  def change
-    # 1. Remove cm_vendor_routes and add cm_routes instead for routes that associated with vendor.
-    drop_table :cm_vendor_routes, if_exists: true
-    create_table :cm_routes, if_not_exists: true do |t|
-      t.string :route_name
-      t.string :short_name
-      t.integer :order_count
-      t.integer :fulfilled_order_count
-      t.integer :route_type
-      t.jsonb :route_stops, default: "[]"
-      t.references :vendor, foreign_key: { to_table: :spree_vendors }, null: false
-      t.references :tenant, foreign_key: { to_table: :cm_tenants }, null: true
-
-      t.references :origin_place, foreign_key: { to_table: :cm_places }, null: false
-      t.references :destination_place, foreign_key: { to_table: :cm_places }, null: false
-
-      t.integer :lock_version, default: 0, null: false
-      t.timestamps
-    end
-
-    # 2. Add indexes for popular_routes association (vendor_id + order by fulfilled_order_count, order_count)
-    add_index :cm_routes, [:vendor_id, :route_type, :fulfilled_order_count, :order_count],
-              order: { fulfilled_order_count: :desc, order_count: :desc },
-              name: 'index_cm_routes_on_vendor_id_route_type_and_popular' unless index_exists?(:cm_routes, [:vendor_id, :route_type, :fulfilled_order_count, :order_count])
-
-    # 3. Add new route reference to cm_trips
-    add_reference :cm_trips, :route, foreign_key: { to_table: :cm_routes }, null: true unless column_exists?(:cm_trips, :route_id)
-  end
-end

data/db/migrate/20260105072450_migrate_cm_trip_stops_to_support_trip_connection.rb

@@ -1,12 +0,0 @@
-class MigrateCmTripStopsToSupportTripConnection < ActiveRecord::Migration[7.0]
-  def change
-    # 1. Replace stop_type with allow_boarding & allow_drop_off instead, it is more flexible.
-    # Useful for middle stops where both boarding & drop off can be allowed or both can be disallowed.
-    remove_column :cm_trip_stops, :stop_type if column_exists?(:cm_trip_stops, :stop_type)
-    add_column :cm_trip_stops, :allow_boarding, :boolean unless column_exists?(:cm_trip_stops, :allow_boarding)
-    add_column :cm_trip_stops, :allow_drop_off, :boolean unless column_exists?(:cm_trip_stops, :allow_drop_off)
-
-    # 2. Add references to link trip stops to trips for boarding, this will enable trip connections. Where current trip is main trip.
-    add_reference :cm_trip_stops, :board_to_trip, foreign_key: { to_table: :cm_trips }, null: true unless column_exists?(:cm_trip_stops, :board_to_trip_id)
-  end
-end

data/db/migrate/20260108101406_add_allow_booking_to_cm_trips.rb

@@ -1,5 +0,0 @@
-class AddAllowBookingToCmTrips < ActiveRecord::Migration[7.0]
-  def change
-    add_column :cm_trips, :allow_booking, :boolean, default: true, if_not_exists: true
-  end
-end

data/lib/spree_cm_commissioner/test_helper/factories/route_metric_factory.rb

@@ -1,12 +0,0 @@
-FactoryBot.define do
-  factory :cm_route_metric, class: SpreeCmCommissioner::RouteMetric do
-    association :origin_place, factory: :cm_place
-    association :destination_place, factory: :cm_place
-
-    route_name { "#{origin_place.name} - #{destination_place.name}" } 
-    route_type { :bus }
-    trip_count { 0 }
-    order_count { 0 }
-    fulfilled_order_count { 0 }
-  end
-end

data/lib/spree_cm_commissioner/test_helper/factories/route_photo_factory.rb

@@ -1,5 +0,0 @@
-FactoryBot.define do
-  factory :cm_route_photo, class: SpreeCmCommissioner::RoutePhoto do
-    attachment { Rack::Test::UploadedFile.new(SpreeMultiVendor::Engine.root.join('spec', 'fixtures', 'thinking-cat.jpg'), 'image/jpeg') }
-  end
-end

data/lib/spree_cm_commissioner/transit/route_stop.rb

@@ -1,61 +0,0 @@
-module SpreeCmCommissioner::Transit
-  class RouteStop
-    attr_accessor :location_id, :vendor_place_id, :type, :sequence, :vendor_place
-
-    STOP_TYPES = %i[branch stop].freeze
-
-    def initialize(options = {})
-      @location_id = options[:location_id]
-      @type = options[:type]&.to_sym
-      @sequence = options[:sequence]
-
-      # vendor place is either stop or branch
-      @vendor_place_id = options[:vendor_place_id]
-    end
-
-    def self.from_hash(hash)
-      hash = hash.symbolize_keys
-
-      new(
-        location_id: hash[:location_id],
-        vendor_place_id: hash[:vendor_place_id],
-        type: hash[:type],
-        sequence: hash[:sequence]
-      )
-    end
-
-    def to_h
-      {
-        location_id: @location_id,
-        vendor_place_id: @vendor_place_id,
-        type: @type,
-        sequence: @sequence
-      }
-    end
-
-    def branch?
-      @type == :branch
-    end
-
-    def stop?
-      @type == :stop
-    end
-
-    def valid?
-      errors.empty?
-    end
-
-    def errors
-      @errors ||= []
-      @errors.clear
-
-      @errors << 'location_id is required' if @location_id.blank?
-      @errors << 'vendor_place_id is required' if @vendor_place_id.blank?
-      @errors << 'type is required' if @type.blank?
-      @errors << 'type must be :branch or :stop' if @type.present? && STOP_TYPES.exclude?(@type)
-      @errors << 'sequence is required' if @sequence.nil?
-
-      @errors
-    end
-  end
-end