unsakini 0.0.4.pre.1 → 0.0.4

data/angular/src/app/services/http/http.service.spec.ts

@@ -1,205 +0,0 @@
-/* tslint:disable:no-unused-variable */
-
-import { TestBed, async, inject } from '@angular/core/testing';
-import { Http, BaseRequestOptions, Response, ResponseOptions, Headers, RequestMethod } from '@angular/http';
-import { MockBackend } from '@angular/http/testing';
-import { HttpService} from '.';
-import { environment } from '../../../environments/environment';
-
-describe('HttpService', () => {
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [
-      	HttpService,
-        BaseRequestOptions,
-        MockBackend,
-        {
-          provide: Http,
-          useFactory: (backend, defaultOptions) => { return new Http(backend, defaultOptions) },
-          deps: [MockBackend, BaseRequestOptions]
-        },
-      ]
-    });
-  });
-
-	it('should be defined', inject([HttpService], (service: HttpService) => {
-    expect(service).toBeTruthy();
-	}));
-
-  describe('Append base api url /', () => {
-
-    let expectMethod = (method: string) => {
-  
-      it(`appends base api url to the ${method} request`, inject([HttpService, MockBackend], (service: HttpService, backend: MockBackend) => {
-        
-        service.base_url = '/'
-        let request_url = '/hello/world'
-
-        backend.connections.subscribe((c) => {
-          expect(c.request.url).toEqual((request_url))
-          c.mockRespond(new Response(new ResponseOptions({ body: 'fake response' })))
-        })
-
-        if (method === 'post' || method === 'put' || method === 'patch')
-          service[method](request_url, {}).subscribe()
-        else
-          service[method](request_url).subscribe()
-      }));
-
-    }
-
-    let methods = ['post', 'get', 'put', 'patch', 'delete']
-
-    for (let i = methods.length - 1; i >= 0; i--) {
-      expectMethod(methods[i])
-    }
-
-  })
-
-  describe('Base url is http://domain.com', () => {
-
-    let expectMethod = (method: string) => {
-  
-      it(`appends base api url to the ${method} request`, inject([HttpService, MockBackend], (service: HttpService, backend: MockBackend) => {
-        let domain = 'http://domain.com'
-        service.base_url = domain
-        let request_url = '/hello/world'
-
-        backend.connections.subscribe((c) => {
-          expect(c.request.url).toEqual(`${domain}${request_url}`)
-          c.mockRespond(new Response(new ResponseOptions({ body: 'fake response' })))
-        })
-
-        if (method === 'post' || method === 'put' || method === 'patch')
-          service[method](request_url, {}).subscribe()
-        else
-          service[method](request_url).subscribe()
-
-      }));
-
-    }
-
-    let methods = ['post', 'get', 'put', 'patch', 'delete']
-
-    for (let i = methods.length - 1; i >= 0; i--) {
-      expectMethod(methods[i])
-    }
-
-  })
-
-  describe('Base url is http://domain.com/, with /', () => {
-
-    let expectMethod = (method: string) => {
-  
-      it(`appends base api url to the ${method} request`, inject([HttpService, MockBackend], (service: HttpService, backend: MockBackend) => {
-        let domain = 'http://domain.com'
-        service.base_url = domain + '/'
-        let request_url = '/hello/world'
-
-        backend.connections.subscribe((c) => {
-          expect(c.request.url).toEqual(`${domain}${request_url}`)
-          c.mockRespond(new Response(new ResponseOptions({ body: 'fake response' })))
-        })
-
-        if (method === 'post' || method === 'put' || method === 'patch')
-          service[method](request_url, {}).subscribe()
-        else
-          service[method](request_url).subscribe()
-
-      }));
-
-    }
-
-    let methods = ['post', 'get', 'put', 'patch', 'delete']
-
-    for (let i = methods.length - 1; i >= 0; i--) {
-      expectMethod(methods[i])
-    }
-
-  })
-
-  describe('Base url dont begin with forward slash (/)', () => {
-
-    let expectMethod = (method: string) => {
-  
-      it(`appends base api url to the ${method} request`, inject([HttpService, MockBackend], (service: HttpService, backend: MockBackend) => {
-        let domain = 'http://domain.com'
-        service.base_url = domain + '/'
-        let request_url = 'hello/world'
-
-        backend.connections.subscribe((c) => {
-          expect(c.request.url).toEqual(`${domain}/${request_url}`)
-          c.mockRespond(new Response(new ResponseOptions({ body: 'fake response' })))
-        })
-
-        if (method === 'post' || method === 'put' || method === 'patch')
-          service[method](request_url, {}).subscribe()
-        else
-          service[method](request_url).subscribe()
-
-      }));
-
-    }
-
-    let methods = ['post', 'get', 'put', 'patch', 'delete']
-
-    for (let i = methods.length - 1; i >= 0; i--) {
-      expectMethod(methods[i])
-    }
-
-  })
-
-  // describe('Registration', () => {
-
-  //   it('jsonizes error', inject([HttpService, MockBackend], (service: HttpService, backend: MockBackend) => {
-      
-  //     let errors = ['name cant be blank']
-
-  //     let mockResponse = new Response(new ResponseOptions({
-  //       status: 422,
-  //       body: errors
-  //     }))
-
-  //     backend.connections.subscribe(c => c.mockError(mockResponse));
-
-  //     let acct: IAccount = {
-  //       name: '',
-  //       email: '',
-  //       password: '',
-  //       password_confirmation: ''
-  //     }
-
-  //     service.registerAccount(acct).subscribe(
-  //       (res) => {},
-  //       (res) => {
-  //         expect(res).toEqual(errors)
-  //       })
-
-  //   }));
-
-  //   it('handles success response', inject([HttpService, MockBackend], (service: HttpService, backend: MockBackend) => {
-      
-  //     let acct: IAccount = {
-  //       name: '',
-  //       email: '',
-  //       password: '',
-  //       password_confirmation: ''
-  //     }
-
-
-  //     let mockResponse = new Response(new ResponseOptions({
-  //       status: 422,
-  //       body: acct
-  //     }))
-
-  //     backend.connections.subscribe(c => c.mockRespond(mockResponse));
-  //     service.registerAccount(acct).subscribe(
-  //       (res) => {
-  //         expect(res).toBe(acct)
-  //       })
-
-  //   }));
-
-  // });
-
-});

data/angular/src/app/services/http/http.service.ts

@@ -1,40 +0,0 @@
-
-import { environment } from '../../../environments/environment';
-import {Injectable} from '@angular/core';
-import {Http, XHRBackend, RequestOptions, Request, RequestOptionsArgs, Response, Headers} from '@angular/http';
-import {Observable} from 'rxjs/Observable';
-import 'rxjs/add/operator/catch';
-import 'rxjs/add/operator/map';
-
-@Injectable()
-
-export class HttpService extends Http {
-
-  base_url = environment.api_base_url;
-  engine_url = '/unsakini'
-
-  constructor (backend: XHRBackend, options: RequestOptions) {
-    super(backend, options);
-  }
-
-  getAuthToken (){
-    localStorage.getItem('auth_token');
-  }
-
-  request(url: string|Request, options?: RequestOptionsArgs): Observable<Response> {
-    if (typeof url === 'string') {
-      url = this.buildUrl(url);
-    } else {
-      url.url = this.buildUrl(url.url);
-    }
-    return super.request(url, options);
-  }
-
-  buildUrl(url: string) {
-    let new_url = `${this.base_url}/${this.engine_url}/${url}`;
-    // remove multiple forward slash from the url like:
-    // http://domain.com//hello/world -> http://domain.com/hello/world
-    return new_url.replace(/([^:]\/)\/+/g, "$1").replace(/(^\/)\/+/g, "$1");
-  }
-
-}

data/angular/src/app/services/http/index.ts

@@ -1 +0,0 @@
-export * from './http.service';

data/angular/src/app/services/index.ts

@@ -1,3 +0,0 @@
-export * from './auth-http/'
-export * from './http'
-export * from './services.module'

data/angular/src/app/services/services.module.ts

@@ -1,33 +0,0 @@
-import { NgModule } from '@angular/core';
-import { HttpModule, XHRBackend, RequestOptions } from '@angular/http';
-
-import { HttpService } from './http/http.service';
-import { AuthHttpService } from './auth-http/auth.http.service';
-
-@NgModule({
-  imports: [
-    HttpModule
-  ],
-  declarations: [
-  ],
-  providers: [
-    {
-      provide: HttpService,
-      useFactory: (backend: XHRBackend, options: RequestOptions) => {
-        return new HttpService(backend, options)
-      },
-      deps: [ XHRBackend, RequestOptions]
-    },
-    {
-      provide: AuthHttpService,
-      useFactory: (backend: XHRBackend, options: RequestOptions) => {
-        return new HttpService(backend, options)
-      },
-      deps: [ XHRBackend, RequestOptions]
-    }
-  ],
-  exports: [
-    HttpModule
-  ]
-})
-export class ServicesModule { }

data/angular/src/assets/global.scss

@@ -1,3 +0,0 @@
-[hidden] {
-  display: none;
-}

data/angular/src/environments/custom.ts

@@ -1,4 +0,0 @@
-export const environment = {
-  production: true,
-  api_base_url: ''
-};

data/app/controllers/concerns/unsakini/board_owner_controller_concern.rb

@@ -1,42 +0,0 @@
-module Unsakini
-  #Ensure user has access to the board and sets the `@board` variable in the controller
-
-  module BoardOwnerControllerConcern
-    extend ActiveSupport::Concern
-
-    #Ensure user has access to the board and sets the `@board` variable in the controller
-    def ensure_board
-      board_id = params[:board_id] || params[:id]
-      result = has_board_access(board_id)
-      @board = result[:board]
-      @user_board = result[:user_board]
-      head result[:status] if result[:status] != :ok
-    end
-
-    # Validate if user has access to board
-    #
-    # @param board_id [Integer] board id
-    def has_board_access(board_id)
-      board = nil
-      if !board_id.nil?
-        board = Unsakini::Board.find_by_id(board_id)
-      else
-        return {status: :bad_request}
-      end
-      if (board)
-        user_board = Unsakini::UserBoard.where(user_id: @user.id, board_id: board_id).first
-        return {status: :forbidden } if user_board.nil?
-        return {status: :ok, board: board, user_board: user_board}
-      else
-        return {status: :not_found}
-      end
-    end
-
-    #Ensures user is owner of the board. Must be run after {#ensure_board} method.
-    def ensure_board_owner
-      render json: {}, status: :forbidden if !@user_board.is_admin
-    end
-
-  end
-
-end

data/app/controllers/concerns/unsakini/comment_owner_controller_concern.rb

@@ -1,36 +0,0 @@
-module Unsakini
-  # Ensures user is owner of the comment and sets the `@comment` variable in the controllers
-  module CommentOwnerControllerConcern
-    extend ActiveSupport::Concern
-
-    # Ensures user is owner of the comment and sets the `@comment` variable in the controllers
-    def ensure_comment
-      post_id = params[:post_id]
-      comment_id = params[:comment_id] || params[:id]
-      result = has_comment_access post_id, comment_id
-      @comment = result[:comment]
-      status = result[:status]
-      head status if status != :ok
-    end
-
-    # Validate if user has access to comment in the post
-    #
-    # @param post_id [Integer] post id
-    # @param comment_id [Integer] comment id
-    def has_comment_access(post_id, comment_id)
-      comment = Unsakini::Comment.where(id: comment_id, post_id: post_id, user_id: @user.id).first
-      if comment.nil?
-        return {status: :forbidden, comment: comment}
-      else
-        return {status: :ok, comment: comment}
-      end
-    end
-
-    # Ensures user is the owner of the comment. Must be run after {#ensure_comment} method.
-    def ensure_comment_owner
-      render json: {}, status: :forbidden if @comment.user_id != @user.id
-    end
-
-  end
-
-end

data/app/controllers/concerns/unsakini/logged_in_controller_concern.rb

@@ -1,23 +0,0 @@
-# Ensures users are logged in and sets `@user` instance variable in the controllers.
-# This is included in the base api controller.
-#
-# Returns `401` error if user is not authenticated
-module Unsakini
-  module LoggedInControllerConcern
-    extend ActiveSupport::Concern
-
-    included do
-      include Knock::Authenticable
-      before_action :ensure_logged_in
-    end
-
-    private
-
-    def ensure_logged_in
-      authenticate_for Unsakini::User
-      @user = current_unsakini_user
-      head :unauthorized unless @user
-    end
-
-  end
-end

data/app/controllers/concerns/unsakini/post_owner_controller_concern.rb

@@ -1,38 +0,0 @@
-# Ensures user is owner of the post and sets the `@post` variable in the controllers
-module Unsakini
-  module PostOwnerControllerConcern
-    extend ActiveSupport::Concern
-
-    # Ensures user is owner of the post and sets the `@post` variable in the controllers
-    def ensure_post
-      post_id = params[:post_id] || params[:id]
-      board_id = params[:board_id]
-      result = has_post_access(board_id, post_id)
-      status = result[:status]
-      @post = result[:post]
-      head status if status != :ok
-    end
-
-    # Validate if user has access to the post in the board
-    #
-    # @param board_id [Integer] board id
-    # @param post_id [Integer] post id
-    def has_post_access(board_id, post_id)
-      post = Unsakini::Post.where(id: post_id, board_id: board_id)
-      .joins("LEFT JOIN #{UserBoard.table_name} ON #{UserBoard.table_name}.board_id = #{Post.table_name}.board_id")
-      .where("#{UserBoard.table_name}.user_id = ?", @user.id)
-      .first
-      if post.nil?
-        return {status: :forbidden}
-      else
-        return {status: :ok, post: post}
-      end
-    end
-
-    # Ensures user is owner of the post. Must be run after {#ensure_post}`.
-    def ensure_post_owner
-      render json: {}, status: :forbidden if @post.user_id != @user.id
-    end
-
-  end
-end

data/app/controllers/concerns/unsakini/serializer_controller_concern.rb

@@ -1,13 +0,0 @@
-module Unsakini
-  module SerializerControllerConcern
-
-    extend ActiveSupport::Concern
-
-    included do
-      include ::ActionController::Serialization
-    end
-
-
-  end
-
-end

data/app/controllers/unsakini/base_controller.rb

@@ -1,6 +0,0 @@
-# Base controller for API controllers
-module Unsakini
-  class BaseController < ActionController::API
-
-  end
-end

data/app/controllers/unsakini/boards_controller.rb

@@ -1,76 +0,0 @@
-
-module Unsakini
-  class BoardsController < BaseController
-
-    include LoggedInControllerConcern
-    include SerializerControllerConcern
-    include BoardOwnerControllerConcern
-    include ::ActionController::Serialization
-
-    before_action :ensure_board, :only => [:show, :update, :destroy]
-    before_action :ensure_board_owner, :only => [:update, :destroy]
-
-    # Returns boards belonging to current user
-    #
-    # `GET /api/boards`
-    #
-    def index
-      admin = true
-      shared = false
-      admin = params[:is_admin] == 'true' if params[:admin]
-      shared = params[:shared] == 'true' if params[:shared]
-      result = @user.user_boards.shared(shared)
-      result = result.admin if admin
-      paginate json: result, per_page: 10
-    end
-
-    # Creates board belonging to current user.
-    #
-    # `POST /api/boards`
-    #
-    def create
-      @user_board = UserBoard.new(
-        name: params[:board][:name],
-        user_id: @user.id,
-        encrypted_password: params[:encrypted_password],
-        is_admin: true
-      )
-      if @user_board.save
-        render json: @user_board, status: :created
-      else
-        render json: @user_board.errors.full_messages, status: 422
-      end
-
-    end
-
-    # Render a single board.
-    #
-    # `GET /api/boards/:id`
-    #
-    def show
-      render json: @user_board
-    end
-
-    # Updates a single board.
-    #
-    # `PUT /api/boards/:id`
-    def update
-      if @user_board.update(name: params[:board][:name], encrypted_password: params[:encrypted_password])
-        render json: @user_board
-      else
-        errors = @board.errors.full_messages.concat @user_board.errors.full_messages
-        render json: errors, status: 422
-      end
-    end
-
-    # Deletes a board resource.
-    #
-    # `DELETE /api/boards/:id`
-    def destroy
-      @board.destroy
-      render json: {}, status: :ok
-    end
-
-  end
-
-end

data/app/controllers/unsakini/comments_controller.rb

@@ -1,54 +0,0 @@
-module Unsakini
-  class CommentsController < BaseController
-
-    include LoggedInControllerConcern
-    include PostOwnerControllerConcern
-    include CommentOwnerControllerConcern
-    include ::ActionController::Serialization
-
-    before_action :ensure_post, only: [:index, :create]
-    before_action :ensure_comment, only: [:show, :update, :destroy]
-    before_action :ensure_comment_owner, only: [:update, :destroy]
-
-    # Renders the comments belonging to the post
-    #
-    # `GET /api/boards/:board_id/posts/:post_id/`
-    def index
-      paginate json: @post.comments.page(params[:page]), per_page: 20
-    end
-
-    # Creates new comment belonging to the post
-    #
-    # `POST /api/boards/:board_id/posts/:post_id/`
-    def create
-      @comment = Comment.new(params.permit(:content))
-      @comment.user = @user
-      @comment.post = @post
-      if @comment.save
-        render json: @comment
-      else
-        render json: @comment.errors, status: 422
-      end
-    end
-
-    # Updates a comment
-    #
-    # `PUT /api/boards/:board_id/posts/:post_id/comments/:id`
-    def update
-      if @comment.update(params.permit(:content))
-        render json: @comment
-      else
-        render json: @comment.errors, status: 422
-      end
-    end
-
-    # Deletes a comment
-    #
-    # `DELETE /api/boards/:board_id/posts/:post_id/comments/:id`
-    def destroy
-      @comment.destroy
-      render json: {}, status: :ok
-    end
-  end
-
-end

data/app/controllers/unsakini/posts_controller.rb

@@ -1,61 +0,0 @@
-module Unsakini
-  class PostsController < BaseController
-
-    include LoggedInControllerConcern
-    include BoardOwnerControllerConcern
-    include PostOwnerControllerConcern
-    include ::ActionController::Serialization
-
-    before_action :ensure_board, only: [:index, :create]
-    before_action :ensure_post, only: [:show, :update, :destroy]
-    before_action :ensure_post_owner, only: [:update, :destroy]
-
-    # Renders the post belonging to the board
-    #
-    # `GET /api/boards/:board_id/posts`
-    def index
-      paginate json: @board.posts.page(params[:page]), per_page: 20
-    end
-
-    # Renders a single post belonging to the board
-    #
-    # `GET /api/boards/:board_id/posts/:id`
-    def show
-      render json: @post
-    end
-
-    # Creates a single post belonging to the board
-    #
-    # `POST /api/boards/:board_id/posts/`
-    def create
-      @post = Post.new(params.permit(:title, :content, :board_id))
-      @post.user = @user
-      if (@post.save)
-        render json: @post, status: :created
-      else
-        render json: @post.errors, status: 422
-      end
-    end
-
-    # Updates a single post belonging to the board
-    #
-    # `PUT /api/boards/:board_id/posts/:id`
-    def update
-      if (@post.update(params.permit(:title, :content)))
-        render json: @post, status: :ok
-      else
-        render json: @post.errors, status: 422
-      end
-    end
-
-    # Deletes a single post belonging to the board
-    #
-    # `DELETE /api/boards/:board_id/posts/:id`
-    def destroy
-      @post.destroy
-      render json: {}, status: :ok
-    end
-
-  end
-
-end