317 src/mock-backend.ts
View file

This file was deleted.

5 src/mocking-mode.ts
View file

This file was deleted.

105 src/resource.service.ts
View file
@@ -8,12 +8,11 @@ import 'rxjs/add/operator/toPromise';
import { Log, Level } from 'ng2-logger';
const log = Log.create('resouce-service', Level.__NOTHING)

import { Eureka } from './eureka';
import { MockingMode } from './mocking-mode';
import { UrlNestedParams } from './nested-params';
import { Rest } from './rest.class';
import { RestRequest } from "./rest-request";
import { RestHeaders } from "./rest-headers";
import { Cookie } from "./cookie";

export interface ResourceModel<A, TA> {
model: (m?: Object) => Rest<A, TA>
@@ -86,7 +85,6 @@ export class Resource<E, T, TA> {
//#region reset
public static reset() {
Resource.endpoints = {};
Resource.mockingModeIsSet = false;
}
//#endregion

@@ -96,8 +94,6 @@ export class Resource<E, T, TA> {
const zone = this.getZone();
RestRequest.zone = zone;
})
if (Resource.__mockingMode === undefined) Resource.__mockingMode = MockingMode.MIX;
log.i('heelooeoeoeo')
}
//#endregion

@@ -111,7 +107,9 @@ export class Resource<E, T, TA> {
}
//#endregion


public static get Cookies() {
return Cookie;
}

//#region docs server
/**
@@ -149,82 +147,10 @@ export class Resource<E, T, TA> {
}
//#endregion

//#region mocking mode
private static mockingModeIsSet = false;
private static get __mockingMode(): MockingMode {
return Rest.mockingMode;
}

private static set __mockingMode(mode) {
Rest.mockingMode = mode;
}
public static setMockingModeOnce = (mode: MockingMode) => Resource.setMockingMode(mode, true)

private static setMockingMode(mode: MockingMode, setOnce = false) {

if (Resource.mockingModeIsSet && !setOnce) {
if (Resource.enableWarnings) console.warn('MOCKING MODE already set for entire application');
return;
}
Resource.mockingModeIsSet = setOnce;
Resource.__mockingMode = mode;
log.i('Mode is set ', mode);
}


/**
* For demo puropse
* Set mocking dynamicly in your app.
* Generaly you should use function setMockingMode(...)
*/
public static mockingMode = {
setDefault: () => {
Resource.setMockingMode(MockingMode.MIX);
},
setMocksOnly: () => {
Resource.setMockingMode(MockingMode.MOCKS_ONLY);
},
setBackendOnly: () => {
Resource.setMockingMode(MockingMode.LIVE_BACKEND_ONLY);
},
isMockOnlyMode: () => Resource.__mockingMode === MockingMode.MOCKS_ONLY,
isBackendOnlyMode: () => Resource.__mockingMode === MockingMode.LIVE_BACKEND_ONLY,
isDefaultMode: () => Resource.__mockingMode === MockingMode.MIX
}
//#endregion

//#region eureka
private static subEurekaEndpointReady: Subject<Eureka.EurekaInstance>
= new Subject<Eureka.EurekaInstance>();
private static obs = Resource.subEurekaEndpointReady.asObservable();

// private static eureka: Eureka<any, any>;
private static mapEureka(config: Eureka.EurekaConfig)
: boolean {
if (!config || !config.serviceUrl || !config.decoderName) {
throw `Bad Eureka config: ${JSON.stringify(config)}`;
}
Rest.eureka = new Eureka.Eureka(config);
Rest.eureka.onInstance.subscribe(ins => {
Resource.endpoints[ins.app] = {
url: ins.instanceId,
models: {}
};
Resource.subEurekaEndpointReady.next(ins);
});
log.i('eureka mapped');
return true;
}
//#endregion

//#region map
private static map(endpoint: string, url: string): boolean {

log.i('url', url)

if (Rest.eureka) {
throw `Canno use 'map()' function after 'mapEureka()'`;
}
let regex = /(http|https):\/\/(\w+:{0,1}\w*)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%!\-\/]))?/;
let e = endpoint;
if (!regex.test(url)) {
@@ -254,21 +180,8 @@ export class Resource<E, T, TA> {
* @param {string} model
* @returns {boolean}
*/
add(endpoint: E, model: string, group?: string, name?: string, description?: string) {
private add(endpoint: E, model: string, group?: string, name?: string, description?: string) {
log.i(`I am maping ${model} on ${<any>endpoint}`);
if (Rest.eureka && Rest.eureka.state === Eureka.EurekaState.DISABLED) {
Rest.eureka.discovery(Resource.request);
}

if (Rest.eureka && Rest.eureka.state !== Eureka.EurekaState.ENABLE // && Rest.eureka.state !== EurekaState.SERVER_ERROR
) {
Resource.subEurekaEndpointReady.subscribe(ins => {
log.i('instance should exist ', ins)
this.add(endpoint, model, group, name, description);
})
return;
}

if (!name) {
let exName: string = model.replace(new RegExp('/', 'g'), ' ');
let slName = exName.split(' ');
@@ -280,11 +193,7 @@ export class Resource<E, T, TA> {
if (model.charAt(0) === '/') model = model.slice(1, model.length);

let e: string;
if (Rest.eureka && Rest.eureka.state === Eureka.EurekaState.ENABLE && Rest.eureka.instance) {
e = Rest.eureka.instance.app;
} else {
e = <string>(endpoint).toString();
}
e = <string>(endpoint).toString();

if (Resource.endpoints[e] === undefined) {
console.error('Endpoint is not mapped ! Cannot add model ' + model);
@@ -310,7 +219,7 @@ export class Resource<E, T, TA> {
* @param {string} model
* @returns {Rest<T, TA>}
*/
api(endpoint: E, model: string, usecase?: string): Rest<T, TA> {
private api(endpoint: E, model: string, usecase?: string): Rest<T, TA> {

if (model.charAt(0) === '/') model = model.slice(1, model.length);
let e = <string>(endpoint).toString();
16 src/rest-request.ts
View file
@@ -6,14 +6,28 @@ import { Subject } from 'rxjs/Subject';
import 'rxjs/add/operator/map';

import { Http } from "./http";
import { MockResponse } from './mock-backend';
import { RestHeaders } from "./rest-headers";

const jobIDkey = 'jobID'

type ReqParams = { url: string, method: Http.HttpMethod, headers?: RestHeaders, body?: any, jobid: number };


export interface MockRequest<T> {
data: any;
params: Object;
restParams?: Object;
body: Object;
method: Http.HttpMethod;
}

export interface MockResponse {
data?: any;
code?: Http.HttpCode;
error?: string;
headers?: RestHeaders;
jobid?: number;
}

export class RestRequest {

172 src/rest.class.ts
View file
@@ -6,12 +6,9 @@ import { Log, Level } from 'ng2-logger';
const log = Log.create('rest.class', Level.__NOTHING)
import * as JSON5 from 'json5';
// local
import { MockingMode } from './mocking-mode';
import { Rest as RestModule } from './rest';
import { UrlNestedParams } from './nested-params';
import { Eureka } from './eureka';
import { Docs } from './docs';
import { MockBackend, MockResponse } from './mock-backend';
import { Http as HttpModule } from './http';
import { RestRequest } from "./rest-request";
import { RestHeaders } from "./rest-headers";
@@ -25,16 +22,14 @@ export class Rest<T, TA = T[]> implements RestModule.FnMethodsHttp<T, TA> {
public static headers: RestHeaders = new RestHeaders();
public static headersResponse: RestHeaders = new RestHeaders();

public static mockingMode: MockingMode;
public __usecase_desc;
public static eureka: Eureka.Eureka<any, any>;
public static waitingForDocsServer: boolean = false;
public static restartServerRequest: boolean = false;

private _endpoint: string;
private _endpointRest: string;
private get endpoint() {
let e = (Rest.eureka && Rest.eureka.instance) ? Rest.eureka.instance.instanceId : this._endpoint;
let e = this._endpoint;
if (this.restQueryParams !== undefined && this._endpointRest !== undefined
&& typeof this._endpointRest === 'string' && this._endpointRest.trim() !== '') e = this._endpointRest;
return e;
@@ -69,7 +64,7 @@ export class Rest<T, TA = T[]> implements RestModule.FnMethodsHttp<T, TA> {
* @memberOf Rest
*/
private appIsWaiting() {
return ((Rest.eureka && Rest.eureka.isWaiting()) || Rest.waitingForDocsServer);
return Rest.waitingForDocsServer;
}

private prepareUrlOldWay = RestModule.prepareUrlOldWay;
@@ -89,9 +84,6 @@ export class Rest<T, TA = T[]> implements RestModule.FnMethodsHttp<T, TA> {
private group: string) {
this._endpoint = endpoint;

// Quick fix
if (Rest.mockingMode === undefined) Rest.mockingMode = MockingMode.MIX;

if (!Rest._headersAreSet) {
Rest._headersAreSet = true;
for (let h in Rest._headers) {
@@ -149,9 +141,6 @@ export class Rest<T, TA = T[]> implements RestModule.FnMethodsHttp<T, TA> {
params?: RestModule.UrlParams[],
doNotSerializeParams: boolean = false,
_sub: Subject<T> = undefined): Observable<T> {
if (Rest.mockingMode === MockingMode.MOCKS_ONLY) {
throw (`In MOCKING MODE you have to define mock of update for enipoint: ${this.endpoint}.`);
}
if (this.appIsWaiting()) {
let sub: Subject<T> = _sub ? _sub : new Subject<T>();
let obs = sub.asObservable();
@@ -211,9 +200,6 @@ export class Rest<T, TA = T[]> implements RestModule.FnMethodsHttp<T, TA> {

//#region jsonp method
jsonp(url?: string, params?: RestModule.UrlParams[], _sub: Subject<T> = undefined): Observable<T> {
if (Rest.mockingMode === MockingMode.MOCKS_ONLY) {
throw (`In MOCKING MODE you have to define mock of jsonp for enipoint: ${this.endpoint}.`);
}
if (this.appIsWaiting()) {
let sub: Subject<T> = _sub ? _sub : new Subject<T>();
let obs = sub.asObservable();
@@ -241,159 +227,5 @@ export class Rest<T, TA = T[]> implements RestModule.FnMethodsHttp<T, TA> {
}
//#endregion

//#region browser mock
private backend: MockBackend.MockAutoBackend<T>;

mock(data: any, timeout: number = 0, controller?: MockBackend.MockController<T>,
nunOfMocks: number = 0): RestModule.FnMethodsHttp<T, TA> {

if (Rest.mockingMode === MockingMode.LIVE_BACKEND_ONLY) {
log.i('FROM MOCK TO LIVE')
return this;
}
let subject: Subject<any>;
let currentMethod: HttpModule.HttpMethod;
let currentBodySend: string;
let currentUrlParams: string;
let currentFullUrl: string;

setTimeout(() => {

if (controller !== undefined) {
let tdata;
if (typeof data === 'object') {
tdata = JSON.parse(JSON.stringify(data));
}
else if (typeof data === 'string') {
tdata = JSON5.parse(data);
}
else {
throw new Error(`Data for mock isn't string or object, endpoint:${this.endpoint}`);
}
if (this.backend === undefined && nunOfMocks > 0)
this.backend = new MockBackend.MockAutoBackend<T>(tdata, nunOfMocks);

let bodyPOSTandPUT = (currentBodySend && typeof currentBodySend === 'string') ? JSON.parse(currentBodySend) : undefined;
log.i('currentFullUrl', currentFullUrl);
let decodedParams = RestModule.decodeUrl(currentFullUrl);
log.i('decodedParams', decodedParams);

let d = nunOfMocks === 0 ? controller({
data: tdata,
params: decodedParams,
body: bodyPOSTandPUT,
restParams: this.restQueryParams,
method: currentMethod
}) :
controller({
data: tdata,
params: decodedParams,
body: bodyPOSTandPUT,
backend: this.backend,
restParams: this.restQueryParams,
method: currentMethod
});
if (d === undefined) {
throw new Error(`Mock controlelr can't return undefined (endpoint:${this.endpoint})`);
}
if (d.error !== undefined) {
console.error(`Mock server respond with code ${d.code} - ${d.error}`);
// TODO each code real message
}

if (d.code === undefined) d.code = 200;
if (d.data === undefined) {
this.log(<Docs.DocModel>{
urlParams: currentUrlParams,
bodySend: currentBodySend,
method: currentMethod,
urlFull: currentFullUrl,
status: d.code,
});
subject.error(d);
}
else {
this.log(<Docs.DocModel>{
urlParams: currentUrlParams,
bodyRecieve: JSON.stringify(d.data),
bodySend: currentBodySend,
method: currentMethod,
urlFull: currentFullUrl,
status: d.code
});
if (this.appIsWaiting()) setTimeout(() => subject.next(d.data), Rest.waitTimeMs);
else subject.next(d.data);
}
}
else {
if (typeof data === 'object' || typeof data === 'string') {
let res: MockResponse = {
data: (typeof data === 'string') ? JSON5.parse(data) : JSON.parse(JSON.stringify(data)),
code: 200
};
this.log(<Docs.DocModel>{
urlParams: currentUrlParams,
bodyRecieve: JSON.stringify(res.data),
bodySend: currentBodySend,
method: currentMethod,
urlFull: currentFullUrl,
status: res.code
});
if (this.appIsWaiting()) setTimeout(() => subject.next(res.data), Rest.waitTimeMs);
else subject.next(res.data);
}
else {
throw new Error(`Data for mock isn't string or object, endpoint:${this.endpoint}`);
}
}
}, timeout);

let t: RestModule.FnMethodsHttp<T, TA> = <RestModule.FnMethodsHttp<T, TA>>{};

const reqMock = (method: HttpModule.HttpMethod, item: T, params?: RestModule.UrlParams[], doNotSerializeParams: boolean = false) => {
currentMethod = method;
subject = new Subject<T>();
RestModule.prepare(params);
currentUrlParams = params ? JSON.stringify(params) : '{}';
currentFullUrl = this.creatUrl(params, doNotSerializeParams);
if (item) currentBodySend = JSON.stringify(item);
return subject.asObservable();
};

t.query = (params?: RestModule.UrlParams[], doNotSerializeParams: boolean = false): Observable<TA> => {
return reqMock('GET', undefined, params, doNotSerializeParams);
};

t.get = (params?: RestModule.UrlParams[], doNotSerializeParams: boolean = false, _sub: any = undefined): Observable<T> => {
return reqMock('GET', undefined, params, doNotSerializeParams);
};

t.save = (item: T, params?: RestModule.UrlParams[], doNotSerializeParams: boolean = false): Observable<T> => {
return reqMock('POST', undefined, params, doNotSerializeParams);
};

t.update = (item: T, params?: RestModule.UrlParams[], doNotSerializeParams: boolean = false): Observable<T> => {
return reqMock('PUT', undefined, params, doNotSerializeParams);
};

t.remove = (params?: RestModule.UrlParams[], doNotSerializeParams: boolean = false): Observable<T> => {
return reqMock('DELETE', undefined, params, doNotSerializeParams);
};

t.jsonp = (url?: string, params?: RestModule.UrlParams[], ): Observable<T> => {
currentMethod = 'JSONP';
subject = new Subject<any>();
RestModule.prepare(params);
let u = (url && UrlNestedParams.checkValidUrl(url)) ? url : this.endpoint;
currentFullUrl = u;

return subject.asObservable();
};


return t;
}
//#endregion

}

187 src/simple-resource.ts
View file

This file was deleted.

2 tests/index.ts
View file
@@ -2,8 +2,6 @@ export * from './mock';
export * from './resource-map';
export * from './resource-add';
export * from './resource-rest';
export * from './resource-mock';
export * from './resource-class-mocking';
export * from './resource-production';
export * from './tests-query-params';
export * from './tests-nested-params';
174 tests/resource-class-mocking.ts
View file

This file was deleted.

1 tests/resource-map.ts
View file
@@ -3,6 +3,7 @@ import {
inject
} from '@angular/core/testing';
import { ApplicationRef, ViewContainerRef } from '@angular/core';
import {} from 'jasmine';
import {
Http, HttpModule,
JsonpModule, XHRBackend, JSONPBackend,
321 tests/resource-mock.ts
View file

This file was deleted.

1 tests/resource-production.ts
View file
@@ -13,7 +13,6 @@ import { MockBackend, MockConnection } from '@angular/http/testing';

import { Resource } from '../src/resource.service';
import { APIS, User } from './mock';
import { MockingMode } from '../src/mocking-mode';

export class TestProduction {

1 tests/resource-rest.ts
View file
@@ -13,7 +13,6 @@ import { MockBackend, MockConnection } from '@angular/http/testing';
import { Rest } from '../src/rest';

import { Resource } from '../src/resource.service';
import { SimpleResource } from '../src/simple-resource';
import { APIS, User } from './mock';

export class TestRest {
1 tests/resource-simple-rest.ts
View file
@@ -13,7 +13,6 @@ import { MockBackend, MockConnection } from '@angular/http/testing';
import { Rest } from '../src/rest';

import { Resource } from '../src/resource.service';
import { SimpleResource } from '../src/simple-resource';
import { APIS, User } from './mock';

export class TestSimpleRest {
8 tests/resource.service.spec.ts
View file
@@ -10,15 +10,13 @@ import {
Jsonp, ConnectionBackend,
} from '@angular/http';
import { MockBackend, MockConnection } from '@angular/http/testing';

import {} from 'jasmine';
import { Resource } from '../src/resource.service';

import {
TestMap,
TestAdd,
TestRest,
TestRestMock,
TestMockingClass,
TestProduction,
TestQueryParams,
TestNestedParams,
@@ -43,13 +41,9 @@ describe('ng2-rest', () => {
});
});

// it( 'shoud be done ', (done) => done() );

new TestMockingClass();
new TestMap();
new TestAdd();
new TestRest();
new TestRestMock();
new TestProduction();
TestQueryParams();
TestNestedParams();
3 tests/tests-nested-params.ts
View file
@@ -6,7 +6,7 @@ import { ViewContainerRef } from '@angular/core';

import { UrlNestedParams } from '../src/nested-params';
import { Resource } from '../src/resource.service';
import { MockRequest } from '../src/mock-backend';
import {} from 'jasmine';
import { APIS, User } from './mock';
import {
Http, HttpModule,
@@ -16,7 +16,6 @@ import {
} from '@angular/http';
import { MockBackend, MockConnection } from '@angular/http/testing';

import { MockingMode } from '../src/mocking-mode';

export function TestNestedParams() {

1 tests/tests-query-params.ts
View file
@@ -1,3 +1,4 @@
import {} from 'jasmine';
import {
TestBed,
inject