rails_auth 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 20e2e8415baf4870033b24dc35caaf7995ff2d8bac0df27a36d1cb2f20660ccd
+  data.tar.gz: 59cfb33bf02c0df186eb7e95e8693de8edd173d5b34bf00f5cc08da9b390e9a7
+SHA512:
+  metadata.gz: 24d55127bc591665489d570074b5181f99ca435f72491f5d213f5a5e2690194238290eb8feea3c783dd0737db0b78f3e94fad6df67d88e6fd4d6e9b32336f3a1
+  data.tar.gz: ad659581a5e17505a43f04ae8af509b68a2733ebf12c4b717b48a565702fd17dd63b9069a20e148aeaa39b965dc06353db8a34fb50dc6b9e52e4e82db528b830

data/README.md

@@ -0,0 +1,39 @@
+# RailsAuth
+
+`RailsAuth`是个处理鉴权的`Rails Engine`
+
+## 特性
+
+- [系列项目说明](https://github.com/yougexiangfa/yougexiangfa)
+- 使用`Rails`自带的`ActiveModel::SecurePassword`模块处理密码;
+
+## 文件说明
+
+
+## 如何使用
+
+
+### 
+
+
+
+```ruby
+class ApplicationController < ActionController::Base
+  include RailsAuthController
+end
+```
+
+#### Include in Model
+
+```ruby
+class User
+  include RailsAuthUser
+end
+```
+
+## The methods RailsAuth provided：
+
+```ruby
+# in controller
+current_user
+```

data/Rakefile

@@ -0,0 +1,38 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'sdoc'
+require 'rdoc/task'
+
+RDoc::Task.new(:sdoc) do |rdoc|
+  rdoc.rdoc_dir = 'docs'
+  rdoc.title = 'TheAuth'
+  rdoc.options << '--format=sdoc'
+  rdoc.options << '-g'
+  rdoc.template = 'rails'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('app/models/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/config/rails_auth_manifest.js

@@ -0,0 +1,2 @@
+//= link_tree ../javascripts/controllers .js
+//= link_tree ../stylesheets/controllers .css

data/app/assets/javascripts/controllers/rails_auth_admin/users/index.js

@@ -0,0 +1,18 @@
+$('#new_q').submit(function(e){
+  for (var i = 0; i < this.elements.length; i++) {
+    if ( this[i].value.length === 0 ) {
+      this[i].disabled = true;
+    }
+
+    if ( this[i].name === 'commit' ) {
+      this[i].disabled = true;
+    }
+
+    if ( this[i].name === 'utf8' ) {
+      this[i].disabled = true;
+    }
+  }
+});
+
+$('.ui.toggle.checkbox').checkbox();
+

data/app/assets/javascripts/controllers/rails_auth_my/users/edit.js

@@ -0,0 +1,20 @@
+attachToInput({
+  input: 'proxy',
+  fileInput: 'file_input',
+  uploadUrl: '/my/user',
+  uploadFieldName: 'user[avatar]',
+  extraParams: {
+    token: '',
+    _method: 'patch'
+  },
+  extraHeaders: {
+    'Accept': 'application/json',
+    'X-CSRF-Token': $('meta[name="csrf-token"]').attr('content')
+  },
+  onFileUploaded: function(filename) {
+    $('#avatar_image').attr('src', filename);
+  }
+});
+
+
+

data/app/assets/javascripts/controllers/rails_auth_my/users/edit.ready.js

@@ -0,0 +1,4 @@
+//= require input-attachment
+
+
+

data/app/assets/javascripts/controllers/rails_auth_web/join/new_mobile.js

@@ -0,0 +1,4 @@
+$('#mobile_confirm').click(function(e){
+  var remind_link = new URL(this.href);
+  $(this).attr('href', remind_link.pathname + '?mobile=' + $('#mobile').val())
+});

data/app/assets/stylesheets/controllers/rails_auth_web/login/new.css

@@ -0,0 +1,4 @@
+
+.column {
+  max-width: 450px;
+}

data/app/assets/stylesheets/controllers/rails_auth_web/password/new.css

@@ -0,0 +1,4 @@
+
+.column {
+  max-width: 450px;
+}

data/app/controllers/concerns/rails_auth_api.rb

@@ -0,0 +1,59 @@
+module RailsAuthApi
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :current_user
+    after_action :set_auth_token
+  end
+
+  def require_login_from_token
+    return if login_from_token
+
+    render(json: { error: @error || 'no user!' }, status: 401)
+  end
+
+  def current_user
+    @current_user ||= login_from_token
+  end
+
+  def login_from_token
+    return if request.headers['HTTP_AUTH_TOKEN'].blank?
+
+    if verify_auth_token
+      @access_token = AccessToken.find_by token: request.headers['HTTP_AUTH_TOKEN']
+    end
+    if @access_token
+      @current_user ||= @access_token.user
+    end
+  end
+
+  private
+  def set_auth_token
+    headers['Auth-Token'] = @current_user.access_token.token if @current_user
+  end
+
+  def verify_auth_token
+    token = request.headers['Auth-Token']
+    payload = decode_without_verification(token)
+
+    return unless payload
+
+    begin
+      password_digest = User.find_by(id: payload['iss']).password_digest.to_s
+      JWT.decode(token, password_digest, true, {'sub' => 'auth', verify_sub: true})
+    rescue => e
+      @error = e.message
+    end
+  end
+
+  def decode_without_verification(token)
+    begin
+      payload, _ = JWT.decode(token, nil, false, verify_expiration: false)
+    rescue => e
+      @error = e.message
+    end
+
+    payload
+  end
+
+end

data/app/controllers/concerns/rails_auth_controller.rb

@@ -0,0 +1,46 @@
+module RailsAuthController
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :current_user
+  end
+
+  def current_user
+    @current_user ||= login_from_session
+  end
+
+  def logout
+    session.delete(:user_id)
+    @current_user = nil
+  end
+
+  def require_login_from_session
+    return if login_from_session
+
+    store_location
+    if params[:form_id]
+      redirect_to login_url(form_id: params[:form_id], login: params[:login])
+    else
+      redirect_to login_url
+    end
+  end
+
+  def login_from_session
+    @current_user ||= User.find_by(id: session[:user_id]) if session[:user_id]
+  end
+
+  def store_location(path = nil)
+    path = path || request.fullpath
+    if ['the_auth_web/login', 'the_auth_web/password'].include? request.params['controller']
+      session[:return_to] = root_url
+    else
+      session[:return_to] = path
+    end
+  end
+
+  def redirect_back_or_default(default = root_url)
+    redirect_to session[:return_to] || default
+    session[:return_to] = nil
+  end
+
+end

data/app/controllers/rails_auth_admin/base_controller.rb

@@ -0,0 +1,5 @@
+class RailsAuthAdmin::BaseController < RailsAuth.config.admin_class.constantize
+  default_form_builder 'RailsAuthAdminFormBuilder'
+
+
+end

data/app/controllers/rails_auth_admin/oauth_users_controller.rb

@@ -0,0 +1,33 @@
+class RailsAuthAdmin::OauthUsersController < RailsAuthAdmin::BaseController
+  before_action :set_oauth_user, only: [:show, :update, :destroy]
+
+  def index
+    if params[:user_id]
+      @user = User.find(params[:user_id])
+      @oauth_users = @user.oauth_users.page(params[:page])
+    else
+      @oauth_users = OauthUser.page(params[:page])
+    end
+  end
+
+  def show
+  end
+
+  def update
+    if @oauth_user.update(oauth_user_params)
+      redirect_to @oauth_user, notice: 'Oauth user was successfully updated.'
+    else
+      render head: :no_content
+    end
+  end
+
+  def destroy
+    @oauth_user.destroy
+    redirect_to oauth_users_url, notice: 'Oauth user was successfully destroyed.'
+  end
+
+  private
+  def set_oauth_user
+    @oauth_user = OauthUser.find(params[:id])
+  end
+end

data/app/controllers/rails_auth_admin/users_controller.rb

@@ -0,0 +1,61 @@
+class RailsAuthAdmin::UsersController < RailsAuthAdmin::BaseController
+  before_action :set_user, only: [:show, :edit, :update, :destroy]
+
+  def index
+    @users = User.includes(:oauth_users).order(created_at: :desc).default_where(search_params).page(params[:page])
+  end
+
+  def new
+    @user = User.new
+  end
+
+  def create
+    @user = User.new(user_params)
+    if @user.join(params)
+      redirect_to admin_users_url, notice: 'User was successfully created.'
+    else
+      render :new
+    end
+  end
+
+  def show
+  end
+
+  def edit
+
+  end
+
+  def update
+    if @user.update(user_params)
+      redirect_to admin_users_url, notice: 'User was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    @user.destroy
+    redirect_to admin_users_url, alert: 'User was successfully destroyed.'
+  end
+
+  private
+  def set_user
+    @user = User.find(params[:id])
+  end
+
+  def search_params
+    params.fetch(:q, {}).permit(:name, :mobile, :email)
+  end
+
+  def user_params
+    params[:user].permit(
+      :name,
+      :avatar,
+      :email,
+      :mobile,
+      :password,
+      :disabled
+    )
+  end
+
+end

data/app/controllers/rails_auth_api/base_controller.rb

@@ -0,0 +1,11 @@
+class RailsAuthApi::BaseController < ActionController::Base
+  skip_before_action :verify_authenticity_token
+  include TheAuthApi
+  include TheCommonApi
+
+  def login_as user
+    user.update(last_login_at: Time.now)
+    @current_user = user
+  end
+
+end

data/app/controllers/rails_auth_api/join_controller.rb

@@ -0,0 +1,105 @@
+class RailsAuthApi::JoinController < RailsAuthApi::BaseController
+
+  #**
+  # @api {get} /verify get verify
+  # @apiName get verify
+  # @apiGroup User
+  #
+  # @apiParam {String} account Email or Mobile number
+  #*
+  def new_verify
+    if params[:account].include?('@')
+      @user = User.find_by(email: params[:account])
+      if @user
+        @verify_token = @user.email_token
+      else
+        @verify_token = EmailToken.valid.find_or_initialize_by(account: params[:account])
+      end
+    else
+      @user = User.find_by(mobile: params[:account])
+      if @user
+        @verify_token = @user.mobile_token
+      else
+        @verify_token = MobileToken.valid.find_or_initialize_by(account: params[:account])
+      end
+    end
+
+    if @verify_token.save_with_send
+      render json: { code: 200, messages: 'Validation code has been sent!' }
+    else
+      render json: { code: 401, messages: 'Token is invalid' }
+    end
+  end
+
+  #**
+  # @api {post} /verify_join Verify
+  # @apiName verify
+  # @apiGroup User
+  #
+  # @apiParam {String} account User mobile number
+  # @apiParam {String} token Mobile verify token
+  # @apiParam {String} password Password
+  #*
+  def create_verify
+    @user = User.find_or_initialize_by(mobile: params[:account])
+    if @user.persisted?
+      @mobile_token = @user.mobile_tokens.valid.find_by(token: params[:token])
+    else
+      @mobile_token = MobileToken.valid.find_by(token: params[:token], account: params[:account])
+      @user = @mobile_token.build_user(mobile: params[:account]) if @mobile_token
+    end
+
+    if @mobile_token
+      @user.mobile_confirm = true
+    else
+      render json: { code: 401, messages: 'Token is invalid' } and return
+    end
+
+    @user.password = params[:password]
+    if @user.save
+      login_as @user
+      render json: { auth_token: @user.access_token.token }
+    else
+      render json: { code: 401, messages:  @user.errors.full_messages }
+    end
+  end
+
+  #**
+  # @api {post} /join Create User
+  # @apiName CreateUser
+  # @apiGroup User
+  #
+  # @apiParam {String} name User name
+  # @apiParam {String} mobile User mobile number
+  # @apiParam {String} token Mobile verify token
+  #*
+  def create
+    @user = User.new(user_params)
+    if @user.join(params)
+      login_as @user
+      render json: { auth_token: @user.access_token.token }
+    else
+      render json: { code: 401, error: @user.errors.full_messages }
+    end
+  end
+
+  private
+  def set_user
+    if params[:account].include?('@')
+      @user = User.find_by(email: params[:account])
+    else
+      @user = User.find_by(mobile: params[:account])
+    end
+  end
+
+  def user_params
+    params.fetch(:user, {}).require(:name, :email).permit(
+      :name,
+      :email,
+      :mobile,
+      :password,
+      :password_confirmation
+    )
+  end
+
+end

data/app/controllers/rails_auth_api/login_controller.rb

@@ -0,0 +1,28 @@
+class RailsAuthApi::LoginController < RailsAuthApi::BaseController
+  before_action :set_user, only: [:create]
+
+  #**
+  #
+  #*
+  def create
+    if @user && @user.can_login?(params)
+      login_as @user
+
+      render json: { status: 200, auth_token: @user.access_token.token }
+    else
+      render json: { error: @user.errors.messages }
+    end
+  end
+
+  private
+  def set_user
+    if params[:account].include?('@')
+      @user = User.find_by(email: params[:account])
+    else
+      @user = User.find_by(mobile: params[:account])
+    end
+  end
+
+end
+
+

data/app/controllers/rails_auth_api/mes_controller.rb

@@ -0,0 +1,25 @@
+class RailsAuthApi::MesController < RailsAuthApi::BaseController
+
+
+  def show
+    render json: current_user.as_json(include: [:oauth_users], methods: [:avatar_url])
+  end
+
+  def edit
+  end
+
+  def update
+    if @me.update(me_params)
+      redirect_to @me, notice: 'Me was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    @me.destroy
+    redirect_to mes_url, notice: 'Me was successfully destroyed.'
+  end
+
+
+end

data/app/controllers/rails_auth_api/oauth_users_controller.rb

@@ -0,0 +1,19 @@
+class RailsAuthApi::OauthUsersController < RailsAuthApi::BaseController
+
+  def create
+    @oauth_user = OauthUser.find_or_initialize_by(type: oauth_user_params[:type], uid: oauth_user_params[:uid])
+    @oauth_user.save_info(oauth_user_params)
+    @oauth_user.init_user
+
+    if @oauth_user.save
+      login_as @oauth_user.user
+      render json: { oauth_user: @oauth_user.as_json, user: @oauth_user.user.as_json }
+    end
+  end
+
+  private
+  def oauth_user_params
+    params.fetch(:oauth_user, {}).permit(:uid, :provider, :type, :name, :access_token, :auth_code)
+  end
+
+end

data/app/controllers/the_auth_my/base_controller.rb

@@ -0,0 +1,4 @@
+class RailsAuthMy::BaseController < RailsAuth.config.my_class.constantize
+
+
+end

data/app/controllers/the_auth_my/oauth_users_controller.rb

@@ -0,0 +1,66 @@
+class RailsAuthMy::OauthUsersController < RailsAuthMy::BaseController
+  before_action :set_user
+  before_action :set_oauth_user, only: [:show, :edit, :update, :destroy]
+
+  def index
+    @oauth_users = current_user.oauth_users
+  end
+
+  def show
+  end
+
+  def new
+    @oauth_user = OauthUser.new
+  end
+
+  def edit
+  end
+
+  def create
+    @oauth_user = OauthUser.new(oauth_user_params)
+
+    respond_to do |format|
+      if @oauth_user.save
+        format.html { redirect_to @oauth_user, notice: 'Oauth user was successfully created.' }
+        format.json { render :show, status: :created, location: @oauth_user }
+      else
+        format.html { render :new }
+        format.json { render json: @oauth_user.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def update
+    respond_to do |format|
+      if @oauth_user.update(oauth_user_params)
+        format.html { redirect_to @oauth_user, notice: 'Oauth user was successfully updated.' }
+        format.json { render :show, status: :ok, location: @oauth_user }
+      else
+        format.html { render :edit }
+        format.json { render json: @oauth_user.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def destroy
+    @oauth_user.destroy
+    respond_to do |format|
+      format.html { redirect_to my_oauth_users_url, notice: 'Oauth user was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+  def set_user
+    @user = current_user
+  end
+
+  def set_oauth_user
+    @oauth_user = OauthUser.find(params[:id])
+  end
+
+  def oauth_user_params
+    params.fetch(:oauth_user, {})
+  end
+
+end

data/app/controllers/the_auth_my/users_controller.rb

@@ -0,0 +1,64 @@
+class RailsAuthMy::UsersController < RailsAuthMy::BaseController
+  before_action :set_user
+
+  def show
+    respond_to do |format|
+      format.js
+      format.html
+      format.json { render json: @user }
+    end
+  end
+
+  def edit
+  end
+
+  def update
+    @user.assign_attributes user_params
+
+    flash[:notice] = 'User was successfully updated.'
+
+    if @user.email_changed?
+      logout
+      flash[:notice] = 'Your Email changed, please login again!'
+      UserMailer.email_confirm(@user.id).deliver_later
+    end
+
+    respond_to do |format|
+      if @user.save
+        format.js
+        format.html { redirect_to my_user_url }
+        format.json {
+          render json: { user: @user.as_json, filename: url_for(@user.avatar) }
+        }
+      else
+        format.html { render action: 'edit' }
+        format.json { render json: @user.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def destroy
+    @user.destroy
+
+    respond_to do |format|
+      format.html { redirect_to my_user_url }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+  def set_user
+    @user = current_user
+  end
+
+  def user_params
+    params.fetch(:user, {}).permit(
+      :email,
+      :name,
+      :mobile,
+      :avatar,
+      :timezone
+    )
+  end
+
+end