jdb/personal-measure
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP Progress on skeleton of the Vue app.

Browse Source
This commit is contained in:
Jonathan Bernard
2019-03-04 18:46:54 -06:00
parent bcde5fbfc0
commit 1b94245078
37 changed files with 536 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
web/src/services/logging/api-appender.ts → web/src/services/logging/api-log-appender.ts
View File

@ -11,7 +11,7 @@ interface ApiMessage {
stacktrace: string;
timestamp: string;
}
export class ApiAppender implements LogAppender {
export class ApiLogAppender implements LogAppender {
public batchSize = 10;
public minimumTimePassedInSec = 60;
public maximumTimePassedInSec = 120;
@ -20,17 +20,17 @@ export class ApiAppender implements LogAppender {
private msgBuffer: ApiMessage[] = [];
private lastSent = 0;
constructor(public readonly apiEndpoint: string, public authToken: string, public threshold?: LogLevel) {
constructor(public readonly apiEndpoint: string, public authToken?: string, public threshold?: LogLevel) {
setInterval(this.checkPost, 1000);
}
public appendMessage(logger: Logger, msg: LogMessage): void {
public appendMessage(msg: LogMessage): void {
if (this.threshold && msg.level < this.threshold) { return; }
this.msgBuffer.push({
level: LogLevel[msg.level],
message: msg.message,
scope: logger.name,
scope: msg.scope,
stacktrace: msg.stacktrace,
timestamp: msg.timestamp.toISOString()
});
@ -49,17 +49,18 @@ export class ApiAppender implements LogAppender {
}
private doPost() {
if (this.msgBuffer.length === 0) { return; }
if (this.msgBuffer.length > 0 && this.authToken) {
this.http.post(this.apiEndpoint, this.msgBuffer,
{ headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${this.authToken}`
}});
this.http.post(this.apiEndpoint, this.msgBuffer,
{ headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${this.authToken}`
}});
this.lastSent = Date.now();
this.msgBuffer = [];
this.lastSent = Date.now();
this.msgBuffer = [];
}
}
}
export default ApiAppender;
export default ApiLogAppender;

13
web/src/services/logging/console-appender.ts → web/src/services/logging/console-log-appender.ts
View File

@ -3,16 +3,17 @@ import { LogMessage, LogLevel} from './log-message';
import Logger from './logger';
import LogAppender from './log-appender';
export class ConsoleAppender implements LogAppender {
export class ConsoleLogAppender implements LogAppender {
constructor(public threshold?: LogLevel) {}
public appendMessage(logger: Logger, msg: LogMessage): void {
public appendMessage(msg: LogMessage): void {
if (this.threshold && msg.level < this.threshold) { return; }
let logMethod = console.log;
switch (msg.level) {
case LogLevel.ALL: logMethod = console.trace; break;
case LogLevel.ALL: logMethod = console.log; break;
case LogLevel.DEBUG: logMethod = console.debug; break;
case LogLevel.LOG: logMethod = console.log; break;
case LogLevel.INFO: logMethod = console.info; break;
case LogLevel.WARN: logMethod = console.warn; break;
case LogLevel.ERROR:
@ -20,11 +21,11 @@ export class ConsoleAppender implements LogAppender {
}
if (msg.error) {
logMethod(logger.name, msg.message, msg.error);
logMethod(`[${msg.scope}]:`, msg.message, msg.error);
} else {
logMethod(logger.name, msg.message, msg.stacktrace);
logMethod(`[${msg.scope}]:`, msg.message, msg.stacktrace);
}
}
}
export default ConsoleAppender;
export default ConsoleLogAppender;

5
web/src/services/logging/index.ts
View File

@ -1,5 +1,6 @@
export * from './log-message';
export * from './log-appender';
export * from './log-service';
export * from './console-appender';
export * from './api-appender';
export * from './console-log-appender';
export * from './api-log-appender';
export * from './logger';

2
web/src/services/logging/log-appender.ts
View File

@ -1,5 +1,5 @@
import { LogLevel, LogMessage } from './log-message';
import Logger from './logger';
export default interface LogAppender {
appendMessage(logger: Logger, message: LogMessage): void;
appendMessage(message: LogMessage): void;
}

3
web/src/services/logging/log-message.ts
View File

@ -1,6 +1,7 @@
export enum LogLevel { ALL = 0, DEBUG, INFO, WARN, ERROR, FATAL }
export enum LogLevel { ALL = 0, DEBUG, LOG, INFO, WARN, ERROR, FATAL }
export interface LogMessage {
scope: string;
level: LogLevel;
message: string;
stacktrace: string;

23
web/src/services/logging/log-service.ts
View File

@ -2,14 +2,24 @@ import { LogLevel } from './log-message';
import Logger from './logger';
import { default as Axios, AxiosInstance } from 'axios';
const ROOT_LOGGER_NAME = 'ROOT';
/* tslint:disable:max-classes-per-file*/
export class LogService {
public static getRootLogger(): Logger { return Logger.ROOT_LOGGER; }
private loggers: { [key: string]: Logger } = { };
private loggers: { [key: string]: Logger };
private http: AxiosInstance = Axios.create();
public get ROOT_LOGGER() {
return this.loggers[ROOT_LOGGER_NAME];
}
public constructor() {
this.loggers = {};
this.loggers[ROOT_LOGGER_NAME] =
new Logger(ROOT_LOGGER_NAME, undefined, LogLevel.ALL);
}
public getLogger(name: string, threshold?: LogLevel): Logger {
if (this.loggers.hasOwnProperty(name)) { return this.loggers[name]; }
@ -17,12 +27,12 @@ export class LogService {
const parentLoggerName = Object.keys(this.loggers)
.filter((n: string) => name.startsWith(n))
.reduce((acc: string, cur: string) => acc.length > cur.length ? acc : cur);
.reduce((acc: string, cur: string) => acc.length > cur.length ? acc : cur, '');
if (parentLoggerName) {
parentLogger = this.loggers[parentLoggerName];
} else {
parentLogger = Logger.ROOT_LOGGER;
parentLogger = this.ROOT_LOGGER;
}
this.loggers[name] = parentLogger.createChildLogger(name, threshold);
@ -30,4 +40,5 @@ export class LogService {
}
}
export default new LogService();
export const logService = new LogService();
export default logService;

50
web/src/services/logging/logger.ts
View File

@ -1,23 +1,29 @@
import { LogMessage, LogLevel } from './log-message';
import LogAppender from './log-appender';
export default class Logger {
public static readonly ROOT_LOGGER = new Logger('ROOT', undefined, LogLevel.ALL);
export class Logger {
public appenders: LogAppender[] = [];
protected constructor(public readonly name: string, private parentLogger?: Logger, public threshold?: LogLevel) { }
public constructor(
public readonly name: string,
private parentLogger?: Logger,
public threshold?: LogLevel) { }
public createChildLogger(name: string, threshold?: LogLevel): Logger {
return new Logger(name, this, threshold);
}
public log(level: LogLevel, message: (Error | string), stacktrace?: string): void {
public doLog(level: LogLevel, message: (Error | string), stacktrace?: string): void {
if (level < this.getEffectiveThreshold()) { return; }
const logMsg: LogMessage = { level, message: '', stacktrace: '', timestamp: new Date() };
const logMsg: LogMessage = {
scope: this.name,
level,
message: '',
stacktrace: '',
timestamp: new Date() };
if (typeof message === 'string') {
logMsg.message = message;
@ -28,29 +34,43 @@ export default class Logger {
logMsg.stacktrace = message.stack == null ? '' : message.stack;
}
this.appenders.forEach((app) => {
app.appendMessage(this, logMsg);
});
this.sendToAppenders(logMsg);
}
public trace(message: (Error | string), stacktrace?: string): void {
this.doLog(LogLevel.ALL, message, stacktrace);
}
public debug(message: (Error | string), stacktrace?: string): void {
this.log(LogLevel.DEBUG, message, stacktrace);
this.doLog(LogLevel.DEBUG, message, stacktrace);
}
public log(message: string, stacktrace?: string): void {
this.doLog(LogLevel.LOG, message, stacktrace);
}
public info(message: string, stacktrace?: string): void {
this.log(LogLevel.INFO, message, stacktrace);
this.doLog(LogLevel.INFO, message, stacktrace);
}
public warn(message: string, stacktrace?: string): void {
this.log(LogLevel.WARN, message, stacktrace);
this.doLog(LogLevel.WARN, message, stacktrace);
}
public error(message: string, stacktrace?: string): void {
this.log(LogLevel.ERROR, message, stacktrace);
this.doLog(LogLevel.ERROR, message, stacktrace);
}
public fatal(message: string, stacktrace?: string): void {
this.log(LogLevel.FATAL, message, stacktrace);
this.doLog(LogLevel.FATAL, message, stacktrace);
}
protected sendToAppenders(logMsg: LogMessage) {
this.appenders.forEach((app) => {
app.appendMessage(logMsg);
});
if (this.parentLogger) { this.parentLogger.sendToAppenders(logMsg); }
}
protected getEffectiveThreshold(): LogLevel {
@ -63,4 +83,4 @@ export default class Logger {
}
export default Logger;

258
web/src/services/pm-api-client.ts
View File

@ -1,9 +1,12 @@
import { default as Axios, AxiosInstance } from 'axios';
import { ApiToken, Measure, Measurement, User } from '@/models';
import { ApiToken, LoginSubmit, Measure, Measurement, User } from '@/models';
import { Logger, logService } from '@/services/logging';
import merge from 'lodash.merge';
export class PmApiClient {
private http: AxiosInstance;
private authToken?: string;
private log: Logger;
constructor(apiBase: string) {
this.http = Axios.create({
@ -16,161 +19,200 @@ export class PmApiClient {
}
*/
});
this.log = logService.getLogger('services/pm-api-client');
this.log.trace('Initialized PmApiClient');
}
public version(): Promise<any> {
return this.http
.get('/version')
.then((resp) => resp.data);
public setAuthToken(t: string) { this.authToken = t; }
public async version(): Promise<string> {
const resp = await this.http.get('/version');
return resp.data;
}
public createAuthToken(email: string, password: string): Promise<string> {
return this.http
.post('/auth-token', { email, password })
.then((resp) => resp.data);
public async createAuthToken(creds: LoginSubmit)
: Promise<string> {
const resp = await this.http.post('/auth-token', creds);
return resp.data;
}
public getUser(authToken: string): Promise<User> {
return this.http
.get('/user', { headers: { Authorization: 'Bearer ' + authToken }})
.then((resp) => merge(resp.data, { authToken }) );
public async getUser(authToken: string): Promise<User> {
const resp = await this.http.get('/user',
{ headers: { Authorization: 'Bearer ' + authToken }});
return merge(resp.data, { authToken }) ;
}
public getAllUsers(user: User): Promise<User[]> {
return this.http
.get('/users', { headers: this.authHeader(user) })
.then((resp) => resp.data);
public async getAllUsers(): Promise<User[]> {
const resp = await this.http.get('/users',
{ headers: this.authHeader() });
return resp.data;
}
public getUserById(curUser: User, reqUserId: string): Promise<User> {
return this.http
.get(`/users/${reqUserId}`, { headers: this.authHeader(curUser) })
.then((resp) => resp.data);
public async getUserById(reqUserId: string): Promise<User> {
const resp = await this.http.get(`/users/${reqUserId}`,
{ headers: this.authHeader() });
return resp.data;
}
public createUser(curUser: User, newUser: User): Promise<User> {
return this.http
.post('/users', newUser, { headers: this.authHeader(curUser) })
.then((resp) => resp.data);
public async createUser(newUser: User): Promise<User> {
const resp = await this.http.post('/users',
newUser, { headers: this.authHeader() });
return resp.data;
}
public deleteUser(curUser: User, toDeleteUserId: string): Promise<boolean> {
return this.http
.delete(`/users/${toDeleteUserId}`, { headers: this.authHeader(curUser) })
.then((resp) => true);
public async deleteUser(toDeleteUserId: string)
: Promise<boolean> {
await this.http.delete(`/users/${toDeleteUserId}`,
{ headers: this.authHeader() });
return true;
}
public changePwd(user: User, oldPassword: string, newPassword: string): Promise<boolean> {
return this.http
.post(
'/change-pwd',
{ oldPassword, newPassword },
{ headers: this.authHeader(user) })
.then((resp) => true);
public async changePwd(oldPassword: string, newPassword: string)
: Promise<boolean> {
await this.http.post('/change-pwd',
{ oldPassword, newPassword }, { headers: this.authHeader() });
return true;
}
public changePwdForUser(user: User, forUserId: string, newPassword: string): Promise<boolean> {
return this.http
.post(
`/change-pwd/${forUserId}`,
{ newPassword },
{ headers: this.authHeader(user) })
.then((resp) => true);
public async changePwdForUser(forUserId: string, newPassword: string)
: Promise<boolean> {
await this.http.post(`/change-pwd/${forUserId}`,
{ newPassword }, { headers: this.authHeader() });
return true;
}
public createApiToken(user: User, token: ApiToken): Promise<ApiToken[]> {
return this.http
.post(`/api-tokens`, token, { headers: this.authHeader(user) })
.then((resp) => resp.data);
public async createApiToken(token: ApiToken)
: Promise<ApiToken[]> {
const resp = await this.http.post(`/api-tokens`,
token, { headers: this.authHeader() });
return resp.data;
}
public getAllApiTokens(user: User): Promise<ApiToken[]> {
return this.http
.get('/api-tokens', { headers: this.authHeader(user) })
.then((resp) => resp.data);
public async getAllApiTokens(): Promise<ApiToken[]> {
const resp = await this.http.get('/api-tokens',
{ headers: this.authHeader() });
return resp.data;
}
public getApiToken(user: User, tokenId: string): Promise<ApiToken[]> {
return this.http
.get(`/api-tokens/${tokenId}`, { headers: this.authHeader(user) })
.then((resp) => resp.data);
public async getApiToken(tokenId: string): Promise<ApiToken[]> {
const resp = await this.http.get(`/api-tokens/${tokenId}`,
{ headers: this.authHeader() });
return resp.data;
}
public deleteApiToken(user: User, tokenId: string): Promise<boolean> {
return this.http
.delete(`/api-tokens/${tokenId}`, { headers: this.authHeader(user) })
.then((resp) => true);
public async deleteApiToken(tokenId: string): Promise<boolean> {
const resp = await this.http.delete(`/api-tokens/${tokenId}`,
{ headers: this.authHeader() });
return true;
}
public getAllMeasures(user: User): Promise<Measure[]> {
return this.http
.get(`/measures`, { headers: this.authHeader(user) })
.then((resp) => resp.data);
public async getAllMeasures(): Promise<Measure[]> {
const resp = await this.http.get(`/measures`,
{ headers: this.authHeader() });
return resp.data;
}
public createMeasure(user: User, measure: Measure): Promise<Measure> {
return this.http
.post(`/measures`, measure, { headers: this.authHeader(user) })
.then((resp) => resp.data);
public async createMeasure(measure: Measure): Promise<Measure> {
const resp = await this.http.post(`/measures`,
measure, { headers: this.authHeader() });
return resp.data;
}
public getMeasure(user: User, slug: string): Promise<Measure> {
return this.http
.get(`/measures/${slug}`, { headers: this.authHeader(user) })
.then((resp) => resp.data);
public async getMeasure(slug: string): Promise<Measure> {
const resp = await this.http.get(`/measures/${slug}`,
{ headers: this.authHeader() });
return resp.data;
}
public deleteMeasure(user: User, slug: string): Promise<boolean> {
return this.http
.delete(`/measures/${slug}`, { headers: this.authHeader(user) })
.then((resp) => true);
public async deleteMeasure(slug: string): Promise<boolean> {
const resp = await this.http.delete(`/measures/${slug}`,
{ headers: this.authHeader() });
return true;
}
public getMeasurements(user: User, measureSlug: string):
Promise<Measurement[]> {
public async getMeasurements(measureSlug: string)
: Promise<Measurement[]> {
return this.http
.get(`/measure/${measureSlug}`, { headers: this.authHeader(user) })
.then((resp) => resp.data);
const resp = await this.http.get(`/measure/${measureSlug}`,
{ headers: this.authHeader() });
return resp.data;
}
public createMeasurement(user: User, measureSlug: string,
measurement: Measurement): Promise<Measurement> {
return this.http
.post(`/measure/${measureSlug}`,
measurement,
{ headers: this.authHeader(user) })
.then((resp) => resp.data);
public async createMeasurement(
measureSlug: string,
measurement: Measurement)
: Promise<Measurement> {
const resp = await this.http.post(`/measure/${measureSlug}`,
measurement, { headers: this.authHeader() });
return resp.data;
}
public getMeasurement(user: User, measureSlug: string, measurementId: string):
Promise<Measurement> {
public async getMeasurement(
measureSlug: string,
measurementId: string)
: Promise<Measurement> {
return this.http
.get(`/measure/${measureSlug}/${measurementId}`,
{ headers: this.authHeader(user) })
.then((resp) => resp.data);
const resp = await this.http.get(`/measure/${measureSlug}/${measurementId}`,
{ headers: this.authHeader() });
return resp.data;
}
public updateMeasurement(user: User, measureSlug: string,
measurement: Measurement): Promise<Measurement> {
return this.http
.put(`/measure/${measureSlug}/${measurement.id}`,
measurement,
{ headers: this.authHeader(user) })
.then((resp) => resp.data) ;
public async updateMeasurement(
measureSlug: string,
measurement: Measurement)
: Promise<Measurement> {
const resp = await this.http.put(`/measure/${measureSlug}/${measurement.id}`,
measurement, { headers: this.authHeader() });
return resp.data;
}
public deleteMeasurement(user: User, measureSlug: string, measurementId: string): Promise<boolean> {
return this.http
.delete(`/measure/${measureSlug}/${measurementId}`,
{headers: this.authHeader(user) })
.then((resp) => true);
public async deleteMeasurement(
measureSlug: string,
measurementId: string)
: Promise<boolean> {
const resp = await this.http.delete(`/measure/${measureSlug}/${measurementId}`,
{headers: this.authHeader() });
return true;
}
private authHeader(user: User): { [key: string]: string } {
return { Authorization: 'Bearer ' + user.authToken };
private authHeader(): { [key: string]: string } {
if (this.authToken) {
return { Authorization: 'Bearer ' + this.authToken };
} else {
throw new Error('no authenticated user');
}
}
}
export default new PmApiClient(process.env.VUE_APP_PM_API_BASE);
export const api = new PmApiClient(process.env.VUE_APP_PM_API_BASE);
export default api;

29
web/src/services/user.ts
View File

@ -1,29 +0,0 @@
import User from '@/models/user.ts';
import { default as apiClient, PmApiClient } from '@/services/pm-api-client.ts';
export class UserService {
private user?: User = undefined;
constructor(private api: PmApiClient) { }
public isAuthed(): boolean {
return this.user != null && this.user.authToken != null;
}
public getUser(): User | undefined { return this.user; }
public authUser(email: string, password: string): Promise<User> {
return this.api.createAuthToken(email, password)
.then((token) => this.api.getUser(token));
}
public getUserById(reqUserId: string): Promise<User> {
if (this.user == null) {
return Promise.reject(new Error('no currently authenticated user'));
} else {
return this.api.getUserById(this.user, reqUserId);
}
}
}
export default new UserService(apiClient);