happy_seed 0.0.19 → 0.0.21

data/lib/generators/happy_seed/api/templates/app/controllers/api/v1/base_controller.rb

@@ -1,7 +1,7 @@
 class Api::V1::BaseController < ApplicationController
   include ModelHash
 
-  attr_accessor :current_user, :current_user_token, :installation_identifier
+  attr_accessor :current_user, :current_user_token
 
   protected
 
@@ -10,11 +10,10 @@ class Api::V1::BaseController < ApplicationController
   end
 
   def requires_authentication_token
-    authenticate_or_request_with_http_token do |token, options|
-      self.installation_identifier = options[:installation_identifier]
-      self.current_user_token = UserToken.where(token: token, installation_identifier: installation_identifier).first
+    authenticate_or_request_with_http_token do |token, _|
+      self.current_user_token = UserToken.find_by access_token: token
       self.current_user = sign_in(:user, current_user_token.user) if current_user_token.try(:user).present?
       current_user.present? ? (current_user_token.try(:touch); true) : false
     end
   end
-end
+end

data/lib/generators/happy_seed/api/templates/app/controllers/api/v1/model_hash.rb

@@ -1,34 +1,17 @@
 module Api::V1::ModelHash
-  def configuration_hash
-    {
-        pusher: {
-            url: Rails.application.secrets.pusher_url
-        },
-        aws: {
-            access_key_id: Rails.application.secrets.aws_access_key_id,
-            secret_access_key: Rails.application.secrets.aws_secret_access_key,
-            s3_bucket: Rails.application.secrets.s3_bucket
-        }
-    }
-  end
-
   def user_hash(user)
     {
         id: user.id,
-        login: user.login,
-        email: user.email,
-        first_name: user.first_name,
-        last_name: user.last_name
+        email: user.email
     }
   end
 
   def user_token_hash(user_token, *args)
     options = args.extract_options!
     output = {
-        token: user_token.token,
-        push_token: user_token.push_token
+        access_token: user_token.access_token
     }
     output.update(user: user_hash(user_token.user)) if true == options[:user]
     output
   end
-end
+end

data/lib/generators/happy_seed/api/templates/app/controllers/api/v1/user_tokens_controller.rb

@@ -3,56 +3,33 @@ class Api::V1::UserTokensController < Api::V1::BaseController
 
   def create
     respond_to do |format|
-      user = User.where('LOWER(email) = ?', user_token_params[:email].try(:downcase)).first
+      user = User.where('LOWER(email) = ?', user_params[:email].try(:downcase)).first
       if user.present?
-        if user.valid_password?(user_token_params[:password])
+        if user.valid_password?(user_params[:password])
           if user.active_for_authentication?
-            user_token = user.user_tokens.where(installation_identifier: user_token_params[:installation_identifier]).first_or_initialize
-            user_token.update push_token: user_token_params[:push_token]
-            user_token.update form_factor: user_token_params[:form_factor]
-            user_token.update os: user_token_params[:os]
+            user_token = user.user_tokens.create
             if user_token.persisted?
               format.json do
-                render json: {user_token: user_token_hash(user_token, user: true)}, status: :ok
+                render json: { user_token: user_token_hash(user_token, user: true) }, status: :ok
               end
             else
               format.json do
-                render json: {errors: user_token.errors}, status: :unprocessable_entity
+                render json: { errors: user_token.errors }, status: :unprocessable_entity
               end
             end
           else
             format.json do
-              render json: {errors: {user: 'is locked'}}, status: :forbidden
+              render json: { errors: { user: 'is locked' } }, status: :forbidden
             end
           end
         else
           format.json do
-            render json: {errors: {password: 'is invalid'}}, status: :forbidden
+            render json: { errors: { password: 'is invalid' } }, status: :forbidden
           end
         end
       else
         format.json do
-          render json: {errors: {email: 'not found'}}, status: :not_found
-        end
-      end
-    end
-  end
-
-  def update
-    respond_to do |format|
-      if current_user_token.try(:persisted?)
-        if current_user_token.update(user_token_params.slice :push_token)
-          format.json do
-            render json: {user_token: user_token_hash(current_user_token)}, status: :ok
-          end
-        else
-          format.json do
-            render json: {errors: current_user_token.errors}, status: :unprocessable_entity
-          end
-        end
-      else
-        format.json do
-          render json: {errors: {token: 'not found'}}, status: :not_found
+          render json: { errors: { email: 'not found' } }, status: :not_found
         end
       end
     end
@@ -63,11 +40,11 @@ class Api::V1::UserTokensController < Api::V1::BaseController
       if current_user_token.try(:persisted?)
         current_user_token.destroy
         format.json do
-          render json: {user_token: user_token_hash(current_user_token, user: true)}, status: :ok
+          render json: { user_token: user_token_hash(current_user_token, user: true) }, status: :ok
         end
       else
         format.json do
-          render json: {errors: {token: 'not found'}}, status: :not_found
+          render json: { errors: { token: 'not found' } }, status: :not_found
         end
       end
     end
@@ -75,7 +52,7 @@ class Api::V1::UserTokensController < Api::V1::BaseController
 
   private
 
-  def user_token_params
-    params[:user_token].permit :email, :password, :installation_identifier, :push_token, :form_factor, :os
+  def user_params
+    params[:user].permit :email, :password
   end
-end
+end

data/lib/generators/happy_seed/api/templates/app/controllers/api/v1/users_controller.rb

@@ -1,4 +1,3 @@
-
 class Api::V1::UsersController < Api::V1::BaseController
   before_action :requires_authentication_token, except: %w(create forgot_password reset_password)
   before_action :set_user, only: %w(show update)
@@ -7,11 +6,11 @@ class Api::V1::UsersController < Api::V1::BaseController
     respond_to do |format|
       if @user.present?
         format.json do
-          render json: {user: user_hash(@user)}, status: :ok
+          render json: { user: user_hash(@user) }, status: :ok
         end
       else
         format.json do
-          render json: {errors: {id: 'not found'}}, status: :not_found
+          render json: { errors: { id: 'not found' } }, status: :not_found
         end
       end
     end
@@ -21,39 +20,19 @@ class Api::V1::UsersController < Api::V1::BaseController
     respond_to do |format|
       user = User.new user_params
       if user.save
-        user_token = user.user_tokens.where(installation_identifier: user_token_params[:installation_identifier]).first_or_create
+        user_token = user.user_tokens.create
         if user_token.persisted?
           format.json do
-            render json: {user_token: user_token_hash(user_token, user: true)}, status: :created
-          end
-        else
-          format.json do
-            render json: {errors: user_token.errors}, status: :unprocessable_entity
-          end
-        end
-      else
-        format.json do
-          render json: {errors: user.errors}, status: :unprocessable_entity
-        end
-      end
-    end
-  end
-
-  def update
-    respond_to do |format|
-      if @user.present?
-        if @user.update(user_params)
-          format.json do
-            render json: {user: user_hash(@user)}, status: :ok
+            render json: { user_token: user_token_hash(user_token, user: true) }, status: :created
           end
         else
           format.json do
-            render json: {errors: @user.errors}, status: :unprocessable_entity
+            render json: { errors: user_token.errors }, status: :unprocessable_entity
           end
         end
       else
         format.json do
-          render json: {errors: {id: 'not found'}}, status: :not_found
+          render json: { errors: user.errors }, status: :unprocessable_entity
         end
       end
     end
@@ -61,14 +40,14 @@ class Api::V1::UsersController < Api::V1::BaseController
 
   def forgot_password
     respond_to do |format|
-      user = FormUser.where(email: user_params[:email]).first
+      user = User.find_by email: user_params[:email]
       format.json do
         if user.present?
           user.send_reset_password_instructions
           user.save
-          render json: {user: user_hash(user).slice(:email)}, status: :ok
+          render json: { user: user_hash(user).slice(:email) }, status: :ok
         else
-          render json: {errors: {email: 'not found'}}, status: :not_found
+          render json: { errors: { email: 'not found' } }, status: :not_found
         end
       end
     end
@@ -80,13 +59,12 @@ class Api::V1::UsersController < Api::V1::BaseController
       format.json do
         if user.present?
           if user.errors.empty?
-            render json: {user: user_hash(user)}, status: :ok
+            render json: { user: user_hash(user) }, status: :ok
           else
-            p user.errors
-            render json: {errors: user.errors}, status: :unprocessable_entity
+            render json: { errors: user.errors }, status: :unprocessable_entity
           end
         else
-          render json: {errors: {email: 'not found'}}, status: :not_found
+          render json: { errors: { email: 'not found' } }, status: :not_found
         end
       end
     end
@@ -99,10 +77,6 @@ class Api::V1::UsersController < Api::V1::BaseController
   end
 
   def user_params
-    params.require(:user).permit :email, :password, :username, :first_name, :last_name, :avatar, :reset_password_token, :password_confirmation, invited: %w(email full_name).map(&:to_sym)
-  end
-
-  def user_token_params
-    params[:user_token].permit :installation_identifier
+    params.require(:user).permit :email, :password, :username, :reset_password_token, :password_confirmation, invited: %w(email full_name).map(&:to_sym)
   end
-end
+end

data/lib/generators/happy_seed/api/templates/config/initializers/apitome.rb

@@ -2,7 +2,7 @@ Apitome.setup do |config|
   # This determines where the Apitome routes will be mounted. Changing this to '/api/documentation' for instance would
   # allow you to browse to http://localhost:3000/api/documentation to see your api documentation. Set to nil and mount
   # it yourself if you need to.
-  config.mount_at = '/api/docs'
+  config.mount_at = '/docs/api'
 
   # This defaults to Rails.root if left nil. If you're providing documentation for an engine using a dummy application
   # it can be useful to set this to your engines root.. E.g. Application::Engine.root

data/lib/generators/happy_seed/api/templates/docs/README.01.api.rdoc

@@ -10,7 +10,10 @@ The `happy_seed:api` generator
 
 ### Why do you want this?
 
-This allows you to invite users to the site and have them sign up through a link.
+1. creates a base api framework for a project that is not exclusively api, and has html as well
+2. creates user signup, login and logout endpoints
+3. creates integration tests for these endpoints
+4. generates documentation at docs/api for these endpoints
 
 ### Environment Variables
 

data/lib/generators/happy_seed/api/templates/docs/api.md

@@ -1,4 +1,4 @@
-Apitome Documentation
-=====================
+Documentation
+=============
 
 This file was automatically generated, and can be found at `docs/api.md`.

data/lib/generators/happy_seed/api/templates/spec/acceptance/api/v1/user_tokens_spec.rb

@@ -5,32 +5,25 @@ resource 'Token' do
   let(:user) { FactoryGirl.create :user_with_token }
 
   post '/v1/token', format: :json do
-    parameter :email, 'Email', required: true, scope: :user_token
-    parameter :password, 'Password', required: true, scope: :user_token
-    parameter :installation_identifier, 'Unique Installation Identifier', required: true, scope: :user_token
-    parameter :push_token, 'Unique push token', required: true, scope: :user_token
-    parameter :form_factor, 'smartphone tablet10 tablet7 desktop', required: true, scope: :user_token
-    parameter :os, 'ios android bb wp7', required: true, scope: :user_token
+    before { user.user_tokens.destroy }
+
+    parameter :email, 'Email', required: true, scope: :user
+    parameter :password, 'Password', required: true, scope: :user
 
     let(:email) { user.email }
     let(:password) { user.password }
-    let(:installation_identifier) { Faker::Lorem.characters 10 }
-    let(:push_token) { Faker::Lorem.characters 10 }
-    let(:form_factor) { %w(smartphone tablet10 tablet7 desktop).sample }
-    let(:os) { %w(ios android bb wp7).sample }
 
     example_request 'sign in' do
       response_json = JSON.parse response_body
 
       expect(response_headers['Content-Type']).to eq('application/json; charset=utf-8')
       expect(status).to eq(200)
-      expect(response_json['user_token']).to have_key('token')
-      expect(response_json['user_token']['push_token']).to eq(push_token)
+      expect(response_json['user_token']).to have_key('access_token')
       expect(response_json['user_token']).to have_key('user')
     end
 
     example 'sign in with wrong email', document: false do
-      do_request params.tap { |parameters| parameters['user_token']['email'] = Faker::Internet.free_email }
+      do_request params.tap { |parameters| parameters['user']['email'] = Faker::Internet.free_email }
       response_json = JSON.parse response_body
 
       expect(status).to eq(404)
@@ -38,62 +31,26 @@ resource 'Token' do
       expect(response_json['errors']).to have_key('email')
     end
 
-    # example 'sign in with locked user', document: false do
-    #   user.lock_access! send_instructions: false
-    #   do_request
-    #   response_json = JSON.parse response_body
-
-    #   expect(status).to eq(403)
-    #   expect(response_json['id']).to be_nil
-    #   expect(response_json['errors']).to have_key('user')
-    # end
-
     example 'sign in with wrong password', document: false do
-      do_request params.tap { |parameters| parameters['user_token']['password'] = Faker::Lorem.characters 8 }
+      do_request params.tap { |parameters| parameters['user']['password'] = Faker::Lorem.characters 8 }
       response_json = JSON.parse response_body
 
       expect(status).to eq(403)
       expect(response_json['id']).to be_nil
       expect(response_json['errors']).to have_key('password')
     end
-
-    example 'sign in without installation identifier', document: false do
-      do_request params.tap { |parameters| parameters['user_token'].delete 'installation_identifier' }
-      response_json = JSON.parse response_body
-
-      expect(status).to eq(422)
-      expect(response_json['id']).to be_nil
-      expect(response_json['errors']).to have_key('installation_identifier')
-    end
-  end
-
-  put '/v1/token', format: :json do
-    header 'AUTHORIZATION', :token
-
-    parameter :push_token, 'Unique push token', required: true, scope: :user_token
-
-    let(:token) { ActionController::HttpAuthentication::Token.encode_credentials user.user_tokens.first.try(:token), installation_identifier: user.user_tokens.first.try(:installation_identifier) }
-    let(:push_token) { Faker::Lorem.characters 10 }
-
-    example_request 'update' do
-      explanation 'At the moment, only push token can be updated'
-      response_json = JSON.parse response_body
-
-      expect(status).to eq(200)
-      expect(response_json['user_token']['push_token']).to eq(push_token)
-    end
   end
 
   delete '/v1/token', format: :json do
     header 'AUTHORIZATION', :token
-    let(:token) { ActionController::HttpAuthentication::Token.encode_credentials user.user_tokens.first.try(:token), installation_identifier: user.user_tokens.first.try(:installation_identifier) }
+    let(:token) { ActionController::HttpAuthentication::Token.encode_credentials user.user_tokens.first.try :access_token }
 
     example_request 'sign out' do
       response_json = JSON.parse response_body
 
       expect(status).to eq(200)
-      expect(response_json['user_token']).to have_key('token')
+      expect(response_json['user_token']).to have_key('access_token')
       expect(response_json['user_token']).to have_key('user')
     end
   end
-end
+end

data/lib/generators/happy_seed/api/templates/spec/acceptance/api/v1/users_spec.rb

@@ -1,51 +1,35 @@
 require 'rails_helper'
 require 'rspec_api_documentation/dsl'
 
-class User
-  def _set_reset_password_token
-    set_reset_password_token
-  end
-end
-
 resource 'User' do
   let(:user) { FactoryGirl.build :user_with_token }
-  # before {
-  #   @request.env["devise.mapping"] = Devise.mappings[:user]
-  # }
 
   post '/v1/users', format: :json do
-    parameter :first_name, 'First Name', scope: :user
-    parameter :last_name, 'Last Name', scope: :user
-    parameter :login, 'Login', required: true, scope: :user
     parameter :email, 'Email', required: true, scope: :user
     parameter :password, 'Password', required: true, scope: :user
-    parameter :installation_identifier, 'Unique Installation Identifier', required: true, scope: :user_token
-    parameter :avatar, 'Avatar', scope: :user
 
-    let(:first_name) { user.first_name }
-    let(:last_name) { user.last_name }
-    let(:login) { user.login }
     let(:email) { user.email }
     let(:password) { user.password }
-    let(:installation_identifier) { Faker::Lorem.characters 10 }
-    # let(:avatar) { fixture_file_upload Rails.root.join('spec', 'resources', 'photo.jpg'), 'image/jpeg' }
 
     example_request 'sign up' do
       response_json = JSON.parse response_body
 
       expect(status).to eq(201)
-      expect(response_json['user_token']).to have_key('token')
+      expect(response_json['user_token']).to have_key('access_token')
       expect(response_json['user_token']).to have_key('user')
     end
-  end
 
-  post '/v1/users/forgot_password', format: :json do
-    before do
-      user.save
-      # @request.env["devise.mapping"] = :user
-      # user.send_reset_password_instructions
+    example 'sign up error', document: false do
+      do_request params.tap { |parameters| parameters['user']['email'] = nil }
+      response_json = JSON.parse response_body
+
+      expect(status).to eq(422)
+      expect(response_json['errors']).to have_key('email')
     end
+  end
 
+  post '/v1/users/forgot_password', format: :json do
+    before { user.save }
 
     parameter :email, 'Email', required: true, scope: :user
     let(:email) { user.email }
@@ -53,28 +37,26 @@ resource 'User' do
     example_request 'forgot password' do
       response_json = JSON.parse response_body
 
-      expect(status).to eq(200)
+      expect(status).to eq 200
       expect(response_json['user']['email']).to eq(email)
     end
   end
 
   put '/v1/users/reset_password', format: :json do
-    before do
-      user.save
-    end
+    before { user.save }
 
     parameter :reset_password_token, 'Reset password token', required: true, scope: :user
     parameter :password, 'Password', required: true, scope: :user
     parameter :password_confirmation, 'Password confirmation', required: true, scope: :user
 
-    let(:reset_password_token) { user._set_reset_password_token }
+    let(:reset_password_token) { user.send :set_reset_password_token }
     let(:password) { Faker::Internet.password 8 }
     let(:password_confirmation) { password }
 
     example_request 'reset password' do
       response_json = JSON.parse response_body
 
-      expect(status).to eq(200)
+      expect(status).to eq 200
       expect(response_json['user']).to have_key('id')
     end
   end
@@ -86,40 +68,14 @@ resource 'User' do
 
     parameter :id, 'User Unique Identifier', required: true
 
-    let(:token) { ActionController::HttpAuthentication::Token.encode_credentials user.user_tokens.first.try(:token), installation_identifier: user.user_tokens.first.try(:installation_identifier) }
+    let(:token) { ActionController::HttpAuthentication::Token.encode_credentials user.user_tokens.first.try(:access_token) }
     let(:id) { user.id }
 
     example_request 'show' do
       response_json = JSON.parse response_body
 
-      expect(status).to eq(200)
+      expect(status).to eq 200
       expect(response_json['user']).to have_key('id')
     end
   end
-
-  put '/v1/users/:id', format: :json do
-    before { user.save }
-
-    header 'AUTHORIZATION', :token
-
-    parameter :id, 'User Unique Identifier', required: true
-    parameter :first_name, 'Full Name', scope: :user
-    parameter :last_name, 'Full Name', scope: :user
-    parameter :login, 'User Name', scope: :user
-
-    let(:token) { ActionController::HttpAuthentication::Token.encode_credentials user.user_tokens.first.try(:token), installation_identifier: user.user_tokens.first.try(:installation_identifier) }
-    let(:id) { user.id }
-    let(:first_name) { Faker::Name.first_name }
-    let(:last_name) { Faker::Name.last_name }
-    let(:login) { Faker::Internet.user_name }
-    # let(:avatar) { fixture_file_upload Rails.root.join('spec', 'resources', 'photo.jpg'), 'image/jpeg' }
-
-    example_request 'update' do
-      explanation 'While this illustrates all possible parameters, any subset can be used. Example: to change only full_name, omit other optional parameters'
-      response_json = JSON.parse response_body
-
-      expect(status).to eq(200)
-      expect(response_json['user']).to have_key('id')
-    end
-  end
-end
+end