unsakini 0.0.4.2 → 0.0.4.3

data/angular/src/app/registration/registration.component.spec.ts

@@ -6,9 +6,9 @@ import 'rxjs/add/observable/of';
 import 'rxjs/add/observable/throw';
 import { By } from '@angular/platform-browser';
 import { DebugElement } from '@angular/core';
-import { Angular2TokenService } from 'angular2-token';
 
 import { RegistrationComponent } from './registration.component';
+import { RegistrationService } from './'
 
 let user = {
   name: 'first last',
@@ -20,7 +20,11 @@ let user = {
 let status = 0
 let errors = []
 
-class Angular2TokenServiceMock {
+class RegistrationServiceMock {
+  success = false
+  expect (success: boolean) {
+    this.success = success;
+  }
   registerAccount(user) {
 
     if (status === 200) {
@@ -56,10 +60,7 @@ describe('RegistrationComponent', () => {
       ],
       declarations: [RegistrationComponent],
       providers: [
-        {
-          provide: Angular2TokenService,
-          useClass: Angular2TokenServiceMock
-        },
+        {provide: RegistrationService, useClass: RegistrationServiceMock}
       ]
     })
     .compileComponents();
@@ -74,14 +75,10 @@ describe('RegistrationComponent', () => {
 
   describe('Component', () => {
 
-    it('should create', () => {
+    it('should be defined', () => {
       expect(component).toBeTruthy();
     });
 
-    it('should have token service', () => {
-      expect(component.service).toBeDefined();
-    });
-
     it('should have user', () => {
       expect(component.user).toEqual({
         name: '',

data/angular/src/app/registration/registration.component.ts

@@ -1,5 +1,5 @@
 import { Component, OnInit } from '@angular/core';
-import { Angular2TokenService } from 'angular2-token';
+import { RegistrationService } from './registration.service';
 
 @Component({
   selector: 'app-registration',
@@ -9,10 +9,15 @@ import { Angular2TokenService } from 'angular2-token';
 export class RegistrationComponent implements OnInit {
 
   user: any;
-  errors: any;
+  errors = {
+    name: [],
+    email: [],
+    password: [],
+    password_confirmation: []
+  };
   success = false;
 
-  constructor(public service: Angular2TokenService) {
+  constructor(public service: RegistrationService) {
     this.user = {
       name: '',
       email: '',
@@ -27,11 +32,8 @@ export class RegistrationComponent implements OnInit {
         this.success = true;
       },
       (res) => {
-        if (res.status == 422) {
-          this.errors = res.json().errors
-        } else {
-          this.errors = ['Something went wrong.']
-        }
+        this.success = false;
+        this.errors = res;
       }
     );
   }

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

@@ -0,0 +1,23 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { RouterModule } from '@angular/router';
+import { ServicesModule } from '../services'
+import { RegistrationComponent } from './registration.component';
+import { RegistrationService } from './registration.service';
+
+@NgModule({
+  imports: [
+    ServicesModule,
+    RouterModule,
+    FormsModule,
+    CommonModule
+  ],
+  declarations: [
+    RegistrationComponent
+  ],
+  providers: [
+    RegistrationService
+  ]
+})
+export class RegistrationModule { }

data/angular/src/app/registration/registration.service.ts

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs/Observable';
+import { Response } from '@angular/http';
+import 'rxjs/add/observable/of';
+import 'rxjs/add/observable/throw';
+import 'rxjs/add/operator/map';
+import 'rxjs/add/operator/catch';
+import { HttpService } from '../services/http/http.service';
+
+export interface IAccount {
+  name: string
+  email: string
+  password: string
+  password_confirmation: string
+}
+
+@Injectable()
+export class RegistrationService {
+
+  constructor(private http: HttpService) {}
+
+  registerAccount(acct: IAccount) {
+    return this.http.post('/user', acct)
+                    .map(this.extractData)
+                    .catch(this.handleError)
+  }
+
+  private extractData (res) {
+    return res.json()
+  }
+
+  private handleError(err: Response) {
+    console.log(err)
+    let errors: any;
+    try {
+      errors = err.json();
+      errors['name'] = errors['name'] || []
+      errors['email'] = errors['email'] || []
+      errors['password'] = errors['password'] || []
+      errors['password_confirmation'] = errors['password_confirmation'] || []
+    } catch (e) {
+      errors = [err.text]
+    }
+    return Observable.throw(errors)
+  }
+}

data/angular/src/app/registration/registration.services.spec.ts

@@ -0,0 +1,71 @@
+
+import { inject, async, ComponentFixture, TestBed } from '@angular/core/testing';
+import { MockBackend, MockConnection } from '@angular/http/testing';
+import { Http, BaseRequestOptions, Response, ResponseOptions } from '@angular/http';
+
+import { HttpService } from '..';
+import { RegistrationService, IAccount } from '.'
+
+describe('RegistrationService', () => {
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        HttpService,
+        RegistrationService,
+        BaseRequestOptions,
+        MockBackend,
+        {
+          provide: Http,
+          useFactory: (backend, defaultOptions) => { return new Http(backend, defaultOptions) },
+          deps: [MockBackend, BaseRequestOptions]
+        },
+      ]
+    });
+  });
+
+  it(`handles error`, inject([MockBackend, RegistrationService], (backend: MockBackend, service: RegistrationService) => {
+    let errors = ['name is required']
+    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: Response) => {}, (err: Response) => {
+      expect(err).toEqual(errors)
+    });
+
+  }))
+
+  it(`handles success`, inject([MockBackend, RegistrationService], (backend: MockBackend, service: RegistrationService) => {
+
+    let acct: IAccount = {
+      name: '',
+      email: '',
+      password: '',
+      password_confirmation: ''
+    }
+
+    let mockResponse = new Response(new ResponseOptions({
+      status: 200,
+      body: acct
+    }))
+
+    backend.connections.subscribe(c => c.mockRespond(mockResponse));
+
+    service.registerAccount(acct).subscribe((res: Response) => {
+      expect(res).toEqual(acct)
+    });
+
+  }))
+
+});

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

@@ -0,0 +1,35 @@
+
+import { environment } from '../../../environments/environment';
+import {HttpService} from '../http';
+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 AuthHttpService extends HttpService {
+
+  base_url = environment.api_base_url;
+
+  constructor (backend: XHRBackend, options: RequestOptions) {
+    super(backend, options);
+  }
+
+  request(url: string|Request, options?: RequestOptionsArgs): Observable<Response> {
+    if (typeof url === 'string') {
+      if (!options) {
+        options = {headers: new Headers()};
+      }
+      options.headers.set('Authorization', `Bearer ${this.getAuthToken()}`);
+    } else {
+      url.headers.set('Authorization', `Bearer ${this.getAuthToken()}`);
+    }
+    return super.request(url, options);
+  }
+
+  getAuthToken () {
+    return localStorage.getItem('auth_token');
+  }
+
+}

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

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

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

@@ -0,0 +1,205 @@
+/* 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

@@ -0,0 +1,40 @@
+
+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

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

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

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

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

@@ -0,0 +1,33 @@
+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

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

data/angular/src/environments/custom.ts

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

data/angular/src/environments/environment.prod.ts

@@ -1,3 +1,4 @@
 export const environment = {
-  production: true
+  production: true,
+  api_base_url: 'https://www.unsakini.com'
 };

data/angular/src/environments/environment.ts

@@ -4,5 +4,6 @@
 // The list of which env maps to which file can be found in `angular-cli.json`.
 
 export const environment = {
-  production: false
+  production: false,
+  api_base_url: '/'
 };

data/angular/src/index.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="utf-8">
   <title>Angular</title>
-  <base href="/app/">
+  <base href="/unsakini/app/">
 
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <link rel="icon" type="image/x-icon" href="favicon.ico">

data/app/controllers/application_controller.rb

@@ -1,5 +1,5 @@
 # Base controller for API controllers
 
-class ApplicationController < ActionController::API
+# class ApplicationController < ActionController::Base
 
-end
+# end

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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,36 @@
+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