effective_classifieds 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4b6ec3f5b89b358551558d22206f8ce57ef5002f199a635c9e004155a12ff246
+  data.tar.gz: 0c36fa15a0dd1ae22c8cd74fef90e8b28bd6bec2e74efe2950c3bb32ee24e999
+SHA512:
+  metadata.gz: 1377dab4d35fc6f2a0c160f006246380cf3af0adabd97100e5b78c61d5c2402c274d747c7eee3ca4126317fe38efc648dc142a549e0be7e31e2f257d4bcbb937
+  data.tar.gz: 2043dfe2ce40bd423fe50c5c80b2c44be329d28c53504c820bb009188382ccb8cdce2596deaf8d374f97786a8cbf09270c8465cb8067edbdaea1a2a1ae0b440a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2022 Code and Effect Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,122 @@
+# Effective Classifieds
+
+Submit classified ads for job openings and equipment sales.
+
+## Getting Started
+
+This requires Rails 6+ and Twitter Bootstrap 4 and just works with Devise.
+
+Please first install the [effective_datatables](https://github.com/code-and-effect/effective_datatables) gem.
+
+Please download and install the [Twitter Bootstrap4](http://getbootstrap.com)
+
+Add to your Gemfile:
+
+```ruby
+gem 'haml-rails' # or try using gem 'hamlit-rails'
+gem 'effective_classifieds'
+```
+
+Run the bundle command to install it:
+
+```console
+bundle install
+```
+
+Then run the generator:
+
+```ruby
+rails generate effective_classifieds:install
+```
+
+The generator will install an initializer which describes all configuration options and creates a database migration.
+
+If you want to tweak the table names, manually adjust both the configuration file and the migration now.
+
+Then migrate the database:
+
+```ruby
+rake db:migrate
+```
+
+Please add the following to your User model:
+
+```
+effective_classifieds_user
+
+Use the following datatables to display to your user their applicants dues:
+
+```haml
+%h2 My Classifieds
+- datatable = EffectiveClassifiedsDatatable.new(self)
+```
+
+and
+
+```
+Add a link to the admin menu:
+
+```haml
+- if can? :admin, :effective_classifieds
+  - if can? :index, Effective::Classified
+    = nav_link_to 'Classifieds', effective_classifieds.admin_classifieds_path
+```
+
+## Configuration
+
+## Authorization
+
+All authorization checks are handled via the effective_resources gem found in the `config/initializers/effective_resources.rb` file.
+
+## Effective Roles
+
+This gem works with effective roles for the representative roles.
+
+Configure your `config/initializers/effective_roles.rb` something like this:
+
+```
+```
+
+## Permissions
+
+The permissions you actually want to define are as follows (using CanCan):
+
+```ruby
+can([:index, :show], Effective::Classified) { |classified| classified.published? }
+can([:show, :edit, :update], Effective::Classified) { |classified| classified.owner == user }
+
+can([:show, :index, :destroy], EffectiveClassifieds.ClassifiedSubmission) { |submission| submission.owner == user }
+can([:update], EffectiveClassifieds.ClassifiedSubmission) { |submission| submission.owner == user && !submission.was_submitted? }
+
+if user.admin?
+  can :admin, :effective_classifieds
+
+  can(crud - [:destroy], Classified)
+
+  can(:approve, Classified) { |classified| classified.was_submitted? && !classified.approved? }
+  can(:destroy, Classified) { |classified| !classified.draft? }
+
+  can([:new, :index, :show], EffectiveClassifieds.ClassifiedSubmission)
+end
+```
+
+## License
+
+MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
+
+## Testing
+
+Run tests by:
+
+```ruby
+rails test
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Bonus points for test coverage
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/assets/config/effective_classifieds_manifest.js

@@ -0,0 +1,3 @@
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css
+//= link_tree ../images

data/app/assets/javascripts/effective_classifieds.js

@@ -0,0 +1 @@
+//= require_tree ./effective_classifieds

data/app/assets/stylesheets/effective_classifieds.scss

@@ -0,0 +1 @@
+@import 'effective_classifieds/base';

data/app/controllers/admin/classified_submissions_controller.rb

@@ -0,0 +1,19 @@
+module Admin
+  class ClassifiedSubmissionsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_classifieds) }
+
+    include Effective::CrudController
+
+    resource_scope -> { EffectiveEvents.ClassifiedSubmission.deep.all }
+    datatable -> { Admin::EffectiveClassifiedSubmissionsDatatable.new }
+
+    private
+
+    def permitted_params
+      model = (params.key?(:effective_classified_submission) ? :effective_classified_submission : :classified_submission)
+      params.require(model).permit!
+    end
+
+  end
+end

data/app/controllers/admin/classifieds_controller.rb

@@ -0,0 +1,20 @@
+module Admin
+  class ClassifiedsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_classifieds) }
+
+    include Effective::CrudController
+
+    submit :save, 'Save'
+    submit :save, 'Save and View', redirect: -> { effective_classifieds.classified_path(resource) }
+    submit :approve, 'Approve'
+
+    private
+
+    def permitted_params
+      model = (params.key?(:effective_classified) ? :effective_classified : :classified)
+      params.require(model).permit!
+    end
+
+  end
+end

data/app/controllers/effective/classified_submissions_controller.rb

@@ -0,0 +1,31 @@
+module Effective
+  class ClassifiedSubmissionsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+
+    include Effective::WizardController
+
+    resource_scope -> { EffectiveClassifieds.ClassifiedSubmission.deep.where(owner: current_user) }
+
+    # Allow only 1 in-progress application at a time
+    before_action(only: [:new, :show], unless: -> { resource&.done? }) do
+      existing = resource_scope.in_progress.where.not(id: resource).first
+
+      if existing.present?
+        flash[:success] = "You have been redirected to your existing in progress classified submission"
+        redirect_to effective_classifieds.classified_submission_build_path(existing, existing.next_step)
+      end
+    end
+
+    after_save do
+      flash.now[:success] = ''
+    end
+
+    private
+
+    def permitted_params
+      model = (params.key?(:effective_classified_submission) ? :effective_classified_submission : :classified_submission)
+      params.require(model).permit!.except(:status, :status_steps, :wizard_steps, :submitted_at)
+    end
+
+  end
+end

data/app/controllers/effective/classifieds_controller.rb

@@ -0,0 +1,53 @@
+module Effective
+  class ClassifiedsController < ApplicationController
+    include Effective::CrudController
+
+    resource_scope -> {
+      unpublished = EffectiveResources.authorized?(self, :admin, :effective_classifieds)
+      Effective::Classified.classifieds(user: current_user, unpublished: unpublished)
+    }
+
+    def index
+      @classifieds ||= resource_scope.published
+
+      @classifieds = @classifieds.paginate(page: params[:page])
+
+      # if params[:search].present?
+      #   search = params[:search].permit(EffectiveClassifieds.permitted_params).delete_if { |k, v| v.blank? }
+      #   @classifieds = @classifieds.where(search) if search.present?
+      # end
+
+      EffectiveResources.authorize!(self, :index, Effective::Classified)
+
+      @page_title ||= ['Classifieds', (" - Page #{params[:page]}" if params[:page])].compact.join
+    end
+
+    def show
+      @classified = resource_scope.find(params[:id])
+
+      if @classified.respond_to?(:roles_permit?)
+        raise Effective::AccessDenied.new('Access Denied', :show, @classified) unless @classified.roles_permit?(current_user)
+      end
+
+      EffectiveResources.authorize!(self, :show, @classified)
+
+      if EffectiveResources.authorized?(self, :admin, :effective_classifieds)
+        flash.now[:warning] = [
+          'Hi Admin!',
+          ('You are viewing a hidden classified.' unless @classified.published?),
+          'Click here to',
+          ("<a href='#{effective_classifieds.edit_admin_classified_path(@classified)}' class='alert-link'>edit classified settings</a>.")
+        ].compact.join(' ')
+      end
+
+      @page_title ||= @classified.to_s
+    end
+
+    private
+
+    def permitted_params
+      params.require(:effective_classified).permit!.except(:status, :status_steps)
+    end
+
+  end
+end

data/app/datatables/admin/effective_classified_submissions_datatable.rb

@@ -0,0 +1,22 @@
+class Admin::EffectiveClassifiedSubmissionsDatatable < Effective::Datatable
+  datatable do
+    order :created_at
+
+    col :token, visible: false
+
+    col :created_at, label: 'Created', visible: false
+    col :updated_at, label: 'Updated', visible: false
+
+    col :submitted_at, label: 'Submitted', visible: false, as: :date
+
+    col :classified, search: :string
+    col :owner
+
+    actions_col
+  end
+
+  collection do
+    EffectiveSubmissions.ClassifiedSubmission.all.deep.done.joins(:classified)
+  end
+
+end

data/app/datatables/admin/effective_classifieds_datatable.rb

@@ -0,0 +1,61 @@
+module Admin
+  class EffectiveClassifiedsDatatable < Effective::Datatable
+    filters do
+      scope :all
+
+      unless EffectiveClassifieds.auto_approve
+        scope :submitted
+        scope :approved
+      end
+
+      scope :published
+    end
+
+    datatable do
+
+      col :updated_at, visible: false
+      col :created_at, visible: false
+
+      col :id, visible: false
+
+      col :classified_submission, visible: false, search: :string
+
+      col :start_on, as: :date
+      col :end_on, as: :date
+
+      if categories.present?
+        col :category, search: categories
+      end
+
+      col :title
+      col :body
+      col :slug, visible: false
+
+      col :organization
+      col :location
+
+      col :website
+      col :email
+      col :phone
+
+      col :archived
+
+      unless EffectiveClassifieds.auto_approve
+        col :status, search: ['submitted', 'approved']
+      end
+
+      actions_col do |classified|
+        dropdown_link_to('View Classified', effective_classifieds.classified_path(classified), target: '_blank')
+      end
+    end
+
+    collection do
+      Effective::Classified.all.where.not(status: :draft)
+    end
+
+    def categories
+      EffectiveClassifieds.categories
+    end
+
+  end
+end

data/app/datatables/effective_classified_submissions_datatable.rb

@@ -0,0 +1,37 @@
+# Dashboard Classified Submissions
+class EffectiveClassifiedSubmissionsDatatable < Effective::Datatable
+  datatable do
+    order :created_at
+
+    col :token, visible: false
+    col :created_at, visible: false
+
+    col :submitted_at do |submission|
+      submission.submitted_at&.strftime('%F') || 'Incomplete'
+    end
+
+    col :classified, search: :string
+
+    col :owner, visible: false, search: :string
+
+    col :status do |submission|
+      submission.classified&.status || submission.status
+    end
+
+    actions_col(actions: []) do |submission|
+      if submission.draft?
+        dropdown_link_to('Continue', effective_classifieds.classified_submission_build_path(submission, submission.next_step), 'data-turbolinks' => false)
+      else
+        dropdown_link_to('Show', effective_classifieds.classified_submission_path(submission))
+        dropdown_link_to('Edit', effective_classifieds.edit_classified_path(submission.classified)) if submission.classified
+      end
+
+      dropdown_link_to('Delete', effective_classifieds.classified_submission_path(submission), 'data-confirm': "Really delete #{submission}?", 'data-method': :delete)
+    end
+  end
+
+  collection do
+    EffectiveClassifieds.ClassifiedSubmission.deep.where(owner: current_user).left_joins(:classified)
+  end
+
+end

data/app/datatables/effective_classifieds_datatable.rb

@@ -0,0 +1,25 @@
+# Dashboard Classifieds
+class EffectiveClassifiedsDatatable < Effective::Datatable
+  datatable do
+    order :start_on
+
+    col :start_on, as: :date, label: 'Starts'
+    col :end_on, as: :date, label: 'Ends'
+
+    col :title
+    col :organization
+    col :location
+
+    col :body, visible: false
+    col :website, visible: false
+    col :email, visible: false
+    col :phone, visible: false
+
+    actions_col(edit: false)
+  end
+
+  collection do
+    Effective::Classified.classifieds(user: current_user)
+  end
+
+end

data/app/helpers/effective_classifieds_helper.rb

@@ -0,0 +1,7 @@
+module EffectiveClassifiedsHelper
+
+  def edit_effective_classified_submissions_wizard?
+    params[:controller] == 'effective/classified_submissions' && defined?(resource) && resource.draft?
+  end
+
+end

data/app/mailers/effective/classifieds_mailer.rb

@@ -0,0 +1,22 @@
+module Effective
+  class ClassifiedsMailer < EffectiveClassifieds.parent_mailer_class
+
+    default from: -> { EffectiveClassifieds.mailer_sender }
+    layout -> { EffectiveClassifieds.mailer_layout || 'effective_classifieds_mailer_layout' }
+
+    def classified_submitted(resource, opts = {})
+      raise('expected an Effective::Classification') unless resource.kind_of?(Effective::Classified)
+
+      @classified = resource
+
+      mail(to: EffectiveClassifieds.mailer_admin, **headers_for(resource, opts))
+    end
+
+    protected
+
+    def headers_for(resource, opts = {})
+      resource.respond_to?(:log_changes_datatable) ? opts.merge(log: resource) : opts
+    end
+
+  end
+end

data/app/models/concerns/effective_classifieds_classified_submission.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+# EffectiveClassifiedsClassifiedSubmission
+#
+# Mark your owner model with effective_classifieds_classified_submission to get all the includes
+
+module EffectiveClassifiedsClassifiedSubmission
+  extend ActiveSupport::Concern
+
+  module Base
+    def effective_classifieds_classified_submission
+      include ::EffectiveClassifiedsClassifiedSubmission
+    end
+  end
+
+  module ClassMethods
+    def effective_classifieds_classified_submission?; true; end
+
+    def all_wizard_steps
+      const_get(:WIZARD_STEPS).keys
+    end
+
+    def required_wizard_steps
+      [:start, :summary, :submitted]
+    end
+  end
+
+  included do
+    acts_as_tokened
+
+    acts_as_statused(
+      :draft,      # Just Started
+      :submitted   # All done
+    )
+
+    acts_as_wizard(
+      start: 'Start',
+      classified: 'Classified',
+      summary: 'Review',
+      submitted: 'Submitted'
+    )
+
+    log_changes(except: :wizard_steps) if respond_to?(:log_changes)
+
+    # Application Namespace
+    belongs_to :owner, polymorphic: true
+    accepts_nested_attributes_for :owner
+
+    # Effective Namespace
+    has_one :classified, class_name: 'Effective::Classified', inverse_of: :classified_submission, dependent: :destroy
+    accepts_nested_attributes_for :classified, reject_if: :all_blank, allow_destroy: true
+
+    effective_resource do
+      # Acts as Statused
+      status                 :string, permitted: false
+      status_steps           :text, permitted: false
+
+      # Dates
+      submitted_at           :datetime
+
+      # Acts as Wizard
+      wizard_steps           :text, permitted: false
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:classified) }
+    scope :sorted, -> { order(:id) }
+
+    scope :in_progress, -> { where.not(status: [:submitted]) }
+    scope :done, -> { where(status: [:submitted]) }
+
+    scope :for, -> (user) { where(owner: user) }
+
+    # All Steps validations
+    validates :owner, presence: true
+
+    # Classified Step
+    with_options(if: -> { current_step == :classified }) do
+      validates :classified, presence: true
+    end
+  end
+
+  # Instance Methods
+  def to_s
+    'classified submission'
+  end
+
+  def in_progress?
+    draft?
+  end
+
+  def done?
+    submitted?
+  end
+
+  # Called on the Review / Summary Step
+  # But we actually want to submit it
+  def summary!
+    submit!
+  end
+
+  def submit!
+    raise('already submitted') if was_submitted?
+
+    classified.submit! unless classified.was_submitted?
+
+    wizard_steps[:submitted] = Time.zone.now
+    submitted!
+  end
+
+end