Merge branch 'develop' of Software_Engineering_I/greenvironment-server into master
commit
d9ff675931
@ -0,0 +1,15 @@
|
||||
# Changelog
|
||||
All notable changes to this project will be documented in this file.
|
||||
|
||||
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
|
||||
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
### Added
|
||||
|
||||
- Connection to Postgres Database
|
||||
- Graphql Schema
|
||||
- default-config file and generation of config file on startup
|
||||
- DTOs
|
||||
- Home Route
|
@ -0,0 +1,12 @@
|
||||
FROM node:current-alpine
|
||||
|
||||
COPY . /home/node/green
|
||||
WORKDIR /home/node/green
|
||||
RUN npm install -g gulp
|
||||
RUN npm install --save-dev
|
||||
RUN npm rebuild node-sass
|
||||
RUN gulp
|
||||
COPY . .
|
||||
EXPOSE 8080
|
||||
EXPOSE 5432
|
||||
CMD ["npm" , "run"]
|
@ -1 +1,11 @@
|
||||
greenvironment-server
|
||||
# greenvironment-server
|
||||
|
||||
Server of the greenvironment social network.
|
||||
|
||||
## Install
|
||||
|
||||
You need to install a nodejs runtime to run the greenvironment server.
|
||||
Then you need to install all requirements. To do so, open a terminal in the
|
||||
greenvironment project folder and execute "npm i". You can build the project by
|
||||
executing "gulp" in the terminal. To run the server you need
|
||||
to execute "node ./dist".
|
||||
|
@ -0,0 +1,15 @@
|
||||
version: "3"
|
||||
services:
|
||||
greenvironment:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: ./Dockerfile
|
||||
user: "node"
|
||||
working_dir: /home/node/green
|
||||
environment:
|
||||
- NODE_ENV=production
|
||||
volumes:
|
||||
- ./:/home/node/green
|
||||
ports:
|
||||
- "8080:8080"
|
||||
command: "npm start"
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,70 @@
|
||||
{
|
||||
"name": "greenvironment-server",
|
||||
"version": "0.1.0",
|
||||
"description": "Server for greenvironment network",
|
||||
"main": "./dist/index.js",
|
||||
"scripts": {
|
||||
"test": "echo \"Error: no test specified\" && exit 1",
|
||||
"build": "gulp",
|
||||
"start": "node ./dist/index.js"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://git.trivernis.net/Software_Engineering_I/greenvironment-server.git"
|
||||
},
|
||||
"keywords": [
|
||||
"server",
|
||||
"nodejs",
|
||||
"express"
|
||||
],
|
||||
"author": "SoftEngI",
|
||||
"license": "ISC",
|
||||
"devDependencies": {
|
||||
"@types/compression": "^1.0.1",
|
||||
"@types/connect-pg-simple": "^4.2.0",
|
||||
"@types/cookie-parser": "^1.4.2",
|
||||
"@types/express": "^4.17.1",
|
||||
"@types/express-graphql": "^0.8.0",
|
||||
"@types/express-session": "^1.15.14",
|
||||
"@types/express-socket.io-session": "^1.3.2",
|
||||
"@types/fs-extra": "^8.0.0",
|
||||
"@types/graphql": "^14.2.3",
|
||||
"@types/http-status": "^0.2.30",
|
||||
"@types/js-yaml": "^3.12.1",
|
||||
"@types/markdown-it": "0.0.9",
|
||||
"@types/node": "^12.7.8",
|
||||
"@types/pg": "^7.11.0",
|
||||
"@types/socket.io": "^2.1.2",
|
||||
"@types/winston": "^2.4.4",
|
||||
"delete": "^1.1.0",
|
||||
"gulp": "^4.0.2",
|
||||
"gulp-minify": "^3.1.0",
|
||||
"gulp-sass": "^4.0.2",
|
||||
"gulp-typescript": "^5.0.1",
|
||||
"ts-lint": "^4.5.1",
|
||||
"tsc": "^1.20150623.0",
|
||||
"tslint": "^5.19.0",
|
||||
"typescript": "^3.5.3"
|
||||
},
|
||||
"dependencies": {
|
||||
"compression": "^1.7.4",
|
||||
"connect-pg-simple": "^6.0.1",
|
||||
"cookie-parser": "^1.4.4",
|
||||
"express": "^4.17.1",
|
||||
"express-graphql": "^0.9.0",
|
||||
"express-session": "^1.16.2",
|
||||
"express-socket.io-session": "^1.3.5",
|
||||
"fs-extra": "^8.1.0",
|
||||
"g": "^2.0.1",
|
||||
"graphql": "^14.4.2",
|
||||
"graphql-import": "^0.7.1",
|
||||
"http-status": "^1.3.2",
|
||||
"js-yaml": "^3.13.1",
|
||||
"markdown-it": "^10.0.0",
|
||||
"markdown-it-emoji": "^1.4.0",
|
||||
"pg": "^7.12.1",
|
||||
"pug": "^2.0.4",
|
||||
"socket.io": "^2.2.0",
|
||||
"winston": "^3.2.1"
|
||||
}
|
||||
}
|
@ -0,0 +1,97 @@
|
||||
import * as compression from "compression";
|
||||
import connectPgSimple = require("connect-pg-simple");
|
||||
import * as cookieParser from "cookie-parser";
|
||||
import * as express from "express";
|
||||
import * as graphqlHTTP from "express-graphql";
|
||||
import * as session from "express-session";
|
||||
import sharedsession = require("express-socket.io-session");
|
||||
import {buildSchema} from "graphql";
|
||||
import {importSchema} from "graphql-import";
|
||||
import * as http from "http";
|
||||
import * as path from "path";
|
||||
import * as socketIo from "socket.io";
|
||||
import {resolver} from "./graphql/resolvers";
|
||||
import dataaccess, {queryHelper} from "./lib/dataaccess";
|
||||
import globals from "./lib/globals";
|
||||
import routes from "./routes";
|
||||
|
||||
const logger = globals.logger;
|
||||
|
||||
const PgSession = connectPgSimple(session);
|
||||
|
||||
class App {
|
||||
public app: express.Application;
|
||||
public io: socketIo.Server;
|
||||
public server: http.Server;
|
||||
|
||||
constructor() {
|
||||
this.app = express();
|
||||
this.server = new http.Server(this.app);
|
||||
this.io = socketIo(this.server);
|
||||
}
|
||||
|
||||
/**
|
||||
* initializes everything that needs to be initialized asynchronous.
|
||||
*/
|
||||
public async init() {
|
||||
await dataaccess.init();
|
||||
await routes.ioListeners(this.io);
|
||||
|
||||
const appSession = session({
|
||||
cookie: {
|
||||
maxAge: Number(globals.config.session.cookieMaxAge) || 604800000,
|
||||
secure: "auto",
|
||||
},
|
||||
resave: false,
|
||||
saveUninitialized: false,
|
||||
secret: globals.config.session.secret,
|
||||
store: new PgSession({
|
||||
pool: dataaccess.pool,
|
||||
tableName: "user_sessions",
|
||||
}),
|
||||
});
|
||||
|
||||
this.io.use(sharedsession(appSession, {autoSave: true}));
|
||||
|
||||
this.app.set("views", path.join(__dirname, "views"));
|
||||
this.app.set("view engine", "pug");
|
||||
this.app.set("trust proxy", 1);
|
||||
|
||||
this.app.use(compression());
|
||||
this.app.use(express.json());
|
||||
this.app.use(express.urlencoded({extended: false}));
|
||||
this.app.use(express.static(path.join(__dirname, "public")));
|
||||
this.app.use(cookieParser());
|
||||
this.app.use(appSession);
|
||||
this.app.use((req, res, next) => {
|
||||
logger.verbose(`${req.method} ${req.url}`);
|
||||
next();
|
||||
});
|
||||
this.app.use(routes.router);
|
||||
this.app.use("/graphql", graphqlHTTP((request, response) => {
|
||||
return {
|
||||
// @ts-ignore all
|
||||
context: {session: request.session},
|
||||
graphiql: true,
|
||||
rootValue: resolver(request, response),
|
||||
schema: buildSchema(importSchema(path.join(__dirname, "./graphql/schema.graphql"))),
|
||||
};
|
||||
}));
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts the web server.
|
||||
*/
|
||||
public start() {
|
||||
if (globals.config.server.port) {
|
||||
logger.info(`Starting server...`);
|
||||
this.app.listen(globals.config.server.port);
|
||||
logger.info(`Server running on port ${globals.config.server.port}`);
|
||||
} else {
|
||||
logger.error("No port specified in the config." +
|
||||
"Please configure a port in the config.yaml.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export default App;
|
@ -0,0 +1,227 @@
|
||||
import {GraphQLError} from "graphql";
|
||||
import * as status from "http-status";
|
||||
import dataaccess from "../lib/dataaccess";
|
||||
import {Chatroom} from "../lib/dataaccess/Chatroom";
|
||||
import {Post} from "../lib/dataaccess/Post";
|
||||
import {Profile} from "../lib/dataaccess/Profile";
|
||||
import {User} from "../lib/dataaccess/User";
|
||||
import {NotLoggedInGqlError} from "../lib/errors/graphqlErrors";
|
||||
import globals from "../lib/globals";
|
||||
import {InternalEvents} from "../lib/InternalEvents";
|
||||
import {is} from "../lib/regex";
|
||||
|
||||
/**
|
||||
* Returns the resolvers for the graphql api.
|
||||
* @param req - the request object
|
||||
* @param res - the response object
|
||||
*/
|
||||
export function resolver(req: any, res: any): any {
|
||||
return {
|
||||
getSelf() {
|
||||
if (req.session.userId) {
|
||||
return new Profile(req.session.userId);
|
||||
} else {
|
||||
res.status(status.UNAUTHORIZED);
|
||||
return new NotLoggedInGqlError();
|
||||
}
|
||||
},
|
||||
async getUser({userId, handle}: { userId: number, handle: string }) {
|
||||
if (handle) {
|
||||
return await dataaccess.getUserByHandle(handle);
|
||||
} else if (userId) {
|
||||
return new User(userId);
|
||||
} else {
|
||||
res.status(status.BAD_REQUEST);
|
||||
return new GraphQLError("No userId or handle provided.");
|
||||
}
|
||||
},
|
||||
async getPost({postId}: { postId: number }) {
|
||||
if (postId) {
|
||||
return await dataaccess.getPost(postId);
|
||||
} else {
|
||||
res.status(status.BAD_REQUEST);
|
||||
return new GraphQLError("No postId given.");
|
||||
}
|
||||
},
|
||||
async getChat({chatId}: { chatId: number }) {
|
||||
if (chatId) {
|
||||
return new Chatroom(chatId);
|
||||
} else {
|
||||
res.status(status.BAD_REQUEST);
|
||||
return new GraphQLError("No chatId given.");
|
||||
}
|
||||
},
|
||||
acceptCookies() {
|
||||
req.session.cookiesAccepted = true;
|
||||
return true;
|
||||
},
|
||||
async login({email, passwordHash}: { email: string, passwordHash: string }) {
|
||||
if (email && passwordHash) {
|
||||
try {
|
||||
const user = await dataaccess.getUserByLogin(email, passwordHash);
|
||||
req.session.userId = user.id;
|
||||
return user;
|
||||
} catch (err) {
|
||||
globals.logger.warn(err.message);
|
||||
globals.logger.debug(err.stack);
|
||||
res.status(status.BAD_REQUEST);
|
||||
return err.graphqlError || err.message;
|
||||
}
|
||||
} else {
|
||||
res.status(status.BAD_REQUEST);
|
||||
return new GraphQLError("No email or password given.");
|
||||
}
|
||||
},
|
||||
logout() {
|
||||
if (req.session.user) {
|
||||
delete req.session.user;
|
||||
return true;
|
||||
} else {
|
||||
res.status(status.UNAUTHORIZED);
|
||||
return new NotLoggedInGqlError();
|
||||
}
|
||||
},
|
||||
async register({username, email, passwordHash}: { username: string, email: string, passwordHash: string }) {
|
||||
if (username && email && passwordHash) {
|
||||
if (!is.email(email)) {
|
||||
res.status(status.BAD_REQUEST);
|
||||
return new GraphQLError(`'${email}' is not a valid email address!`);
|
||||
}
|
||||
try {
|
||||
const user = await dataaccess.registerUser(username, email, passwordHash);
|
||||
req.session.userId = user.id;
|
||||
return user;
|
||||
} catch (err) {
|
||||
globals.logger.warn(err.message);
|
||||
globals.logger.debug(err.stack);
|
||||
res.status(status.BAD_REQUEST);
|
||||
return err.graphqlError || err.message;
|
||||
}
|
||||
} else {
|
||||
res.status(status.BAD_REQUEST);
|
||||
return new GraphQLError("No username, email or password given.");
|
||||
}
|
||||
},
|
||||
async vote({postId, type}: { postId: number, type: dataaccess.VoteType }) {
|
||||
if (postId && type) {
|
||||
if (req.session.userId) {
|
||||
return await (new Post(postId)).vote(req.session.userId, type);
|
||||
} else {
|
||||
res.status(status.UNAUTHORIZED);
|
||||
return new NotLoggedInGqlError();
|
||||
}
|
||||
} else {
|
||||
res.status(status.BAD_REQUEST);
|
||||
return new GraphQLError("No postId or type given.");
|
||||
}
|
||||
},
|
||||
async createPost({content}: { content: string }) {
|
||||
if (content) {
|
||||
if (req.session.userId) {
|
||||
const post = await dataaccess.createPost(content, req.session.userId);
|
||||
globals.internalEmitter.emit(InternalEvents.GQLPOSTCREATE, post);
|
||||
return post;
|
||||
} else {
|
||||
res.status(status.UNAUTHORIZED);
|
||||
return new NotLoggedInGqlError();
|
||||
}
|
||||
} else {
|
||||
res.status(status.BAD_REQUEST);
|
||||
return new GraphQLError("Can't create empty post.");
|
||||
}
|
||||
},
|
||||
async deletePost({postId}: { postId: number }) {
|
||||
if (postId) {
|
||||
const post = new Post(postId);
|
||||
if ((await post.author()).id === req.session.userId) {
|
||||
return await dataaccess.deletePost(post.id);
|
||||
} else {
|
||||
res.status(status.FORBIDDEN);
|
||||
return new GraphQLError("User is not author of the post.");
|
||||
}
|
||||
} else {
|
||||
return new GraphQLError("No postId given.");
|
||||
}
|
||||
},
|
||||
async createChat({members}: { members: number[] }) {
|
||||
if (req.session.userId) {
|
||||
const chatMembers = [req.session.userId];
|
||||
if (members) {
|
||||
chatMembers.push(...members);
|
||||
}
|
||||
return await dataaccess.createChat(...chatMembers);
|
||||
} else {
|
||||
res.status(status.UNAUTHORIZED);
|
||||
return new NotLoggedInGqlError();
|
||||
}
|
||||
},
|
||||
async sendMessage({chatId, content}: { chatId: number, content: string }) {
|
||||
if (!req.session.userId) {
|
||||
res.status(status.UNAUTHORIZED);
|
||||
return new NotLoggedInGqlError();
|
||||
}
|
||||
if (chatId && content) {
|
||||
try {
|
||||
const message = await dataaccess.sendChatMessage(req.session.userId, chatId, content);
|
||||
globals.internalEmitter.emit(InternalEvents.GQLCHATMESSAGE, message);
|
||||
return message;
|
||||
} catch (err) {
|
||||
globals.logger.warn(err.message);
|
||||
globals.logger.debug(err.stack);
|
||||
res.status(status.BAD_REQUEST);
|
||||
return err.graphqlError || err.message;
|
||||
}
|
||||
} else {
|
||||
res.status(status.BAD_REQUEST);
|
||||
return new GraphQLError("No chatId or content given.");
|
||||
}
|
||||
},
|
||||
async sendRequest({receiver, type}: { receiver: number, type: dataaccess.RequestType }) {
|
||||
if (!req.session.userId) {
|
||||
res.status(status.UNAUTHORIZED);
|
||||
return new NotLoggedInGqlError();
|
||||
}
|
||||
if (receiver && type) {
|
||||
return await dataaccess.createRequest(req.session.userId, receiver, type);
|
||||
} else {
|
||||
res.status(status.BAD_REQUEST);
|
||||
return new GraphQLError("No receiver or type given.");
|
||||
}
|
||||
},
|
||||
async denyRequest({sender, type}: { sender: number, type: dataaccess.RequestType }) {
|
||||
if (!req.session.userId) {
|
||||
res.status(status.UNAUTHORIZED);
|
||||
return new NotLoggedInGqlError();
|
||||
}
|
||||
if (sender && type) {
|
||||
const profile = new Profile(req.session.userId);
|
||||
await profile.denyRequest(sender, type);
|
||||
return true;
|
||||
} else {
|
||||
res.status(status.BAD_REQUEST);
|
||||
return new GraphQLError("No sender or type given.");
|
||||
}
|
||||
},
|
||||
async acceptRequest({sender, type}: { sender: number, type: dataaccess.RequestType }) {
|
||||
if (!req.session.userId) {
|
||||
res.status(status.UNAUTHORIZED);
|
||||
return new NotLoggedInGqlError();
|
||||
}
|
||||
if (sender && type) {
|
||||
try {
|
||||
const profile = new Profile(req.session.userId);
|
||||
await profile.acceptRequest(sender, type);
|
||||
return true;
|
||||
} catch (err) {
|
||||
globals.logger.warn(err.message);
|
||||
globals.logger.debug(err.stack);
|
||||
res.status(status.BAD_REQUEST);
|
||||
return err.graphqlError || err.message;
|
||||
}
|
||||
} else {
|
||||
res.status(status.BAD_REQUEST);
|
||||
return new GraphQLError("No sender or type given.");
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
@ -0,0 +1,236 @@
|
||||
type Query {
|
||||
"returns the user object for a given user id or a handle (only one required)"
|
||||
getUser(userId: ID, handle: String): User
|
||||
|
||||
"returns the logged in user"
|
||||
getSelf: Profile
|
||||
|
||||
"returns the post object for a post id"
|
||||
getPost(postId: ID!): Post
|
||||
|
||||
"returns the chat object for a chat id"
|
||||
getChat(chatId: ID!): ChatRoom
|
||||
|
||||
"find a post by the posted date or content"
|
||||
findPost(first: Int, offset: Int, text: String!, postedDate: String): [Post]
|
||||
|
||||
"find a user by user name or handle"
|
||||
findUser(first: Int, offset: Int, name: String!, handle: String!): [User]
|
||||
}
|
||||
|
||||
type Mutation {
|
||||
"Accepts the usage of cookies."
|
||||
acceptCookies: Boolean
|
||||
|
||||
"Login of the user. The passwordHash should be a sha512 hash of the password."
|
||||
login(email: String, passwordHash: String): Profile
|
||||
|
||||
"Registers the user."
|
||||
register(username: String, email: String, passwordHash: String): Profile
|
||||
|
||||
"Logout of the user."
|
||||
logout: Boolean
|
||||
|
||||
"Upvote/downvote a Post"
|
||||
vote(postId: ID!, type: VoteType!): VoteType
|
||||
|
||||
"Report the post"
|
||||
report(postId: ID!): Boolean
|
||||
|
||||
"send a request"
|
||||
sendRequest(receiver: ID!, type: RequestType): Request
|
||||
|
||||
"lets you accept a request for a given request id"
|
||||
acceptRequest(sender: ID!, type: RequestType): Boolean
|
||||
|
||||
"lets you deny a request for a given request id"
|
||||
denyRequest(requestId: ID!): Boolean
|
||||
|
||||
"send a message in a Chatroom"
|
||||
sendMessage(chatId: ID!, content: String!): ChatMessage
|
||||
|
||||
"create the post"
|
||||
createPost(content: String!): Post
|
||||
|
||||
"delete the post for a given post id"
|
||||
deletePost(postId: ID!): Boolean
|
||||
|
||||
"Creates a chat between the user (and optional an other user)"
|
||||
createChat(members: [ID!]): ChatRoom
|
||||
}
|
||||
|
||||
interface UserData {
|
||||
"url for the Profile picture of the User"
|
||||
profilePicture: String
|
||||
|
||||
"name of the User"
|
||||
name: String!
|
||||
|
||||
"unique identifier name from the User"
|
||||
handle: String!
|
||||
|
||||
"Id of the User"
|
||||
id: ID!
|
||||
|
||||
"the total number of posts the user posted"
|
||||
numberOfPosts: Int
|
||||
|
||||
"returns a given number of posts of a user"
|
||||
posts(first: Int=10, offset: Int): [Post]
|
||||
|
||||
"creation date of the user account"
|
||||
joinedAt: String!
|
||||
|
||||
"all friends of the user"
|
||||
friends: [User]
|
||||
}
|
||||
|
||||
"represents a single user account"
|
||||
type User implements UserData{
|
||||
"url for the Profile picture of the User"
|
||||
profilePicture: String
|
||||
|
||||
"name of the User"
|
||||
name: String!
|
||||
|
||||
"unique identifier name from the User"
|
||||
handle: String!
|
||||
|
||||
"Id of the User"
|
||||
id: ID!
|
||||
|
||||
"the total number of posts the user posted"
|
||||
numberOfPosts: Int
|
||||
|
||||
"returns a given number of posts of a user"
|
||||
posts(first: Int=10, offset: Int): [Post]
|
||||
|
||||
"creation date of the user account"
|
||||
joinedAt: String!
|
||||
|
||||
"all friends of the user"
|
||||
friends: [User]
|
||||
}
|
||||
|
||||
type Profile implements UserData {
|
||||
"url for the Profile picture of the User"
|
||||
profilePicture: String
|
||||
|
||||
"name of the User"
|
||||
name: String!
|
||||
|
||||
"returns the chatrooms the user joined."
|
||||
chats(first: Int=10, offset: Int): [ChatRoom]
|
||||
|
||||
"unique identifier name from the User"
|
||||
handle: String!
|
||||
|
||||
"Id of the User"
|
||||
id: ID!
|
||||
|
||||
"the total number of posts the user posted"
|
||||
numberOfPosts: Int
|
||||
|
||||
"returns a given number of posts of a user"
|
||||
posts(first: Int=10, offset: Int): [Post]
|
||||
|
||||
"creation date of the user account"
|
||||
joinedAt: String!
|
||||
|
||||
"all friends of the user"
|
||||
friends: [User]
|
||||
|
||||
"all sent request for groupChats/friends/events"
|
||||
sentRequests: [Request]
|
||||
|
||||
"all received request for groupChats/friends/events"
|
||||
receivedRequests: [Request]
|
||||
}
|
||||
|
||||
"represents a single user post"
|
||||
type Post {
|
||||
|
||||
"The id of the post."
|
||||
id: ID!
|
||||
|
||||
"the text of the post"
|
||||
content: String
|
||||
|
||||
"the content of the post rendered by markdown-it"
|
||||
htmlContent: String
|
||||
|
||||
"upvotes of the Post"
|
||||
upvotes: Int!
|
||||
|
||||
"downvotes of the Post"
|
||||
downvotes: Int!
|
||||
|
||||
"the user that is the author of the Post"
|
||||
author: User!
|
||||
|
||||
"date the post was created"
|
||||
createdAt: String!
|
||||
|
||||
"the type of vote the user performed on the post"
|
||||
userVote: VoteType
|
||||
}
|
||||
|
||||
"represents a request of any type"
|
||||
type Request {
|
||||
"Id of the user who sended the request"
|
||||
sender: User!
|
||||
|
||||
"Id of the user who received the request"
|
||||
receiver: User!
|
||||
|
||||
"type of the request"
|
||||
type: RequestType!
|
||||
}
|
||||
|
||||
"represents a chatroom"
|
||||
type ChatRoom {
|
||||
"the socket.io namespace for the chatroom"
|
||||
namespace: String
|
||||
|
||||
"the members of the chatroom"
|
||||
members: [User!]
|
||||
|
||||
"return a specfic range of messages posted in the chat"
|
||||
messages(first: Int = 10, offset: Int, containing: String): [ChatMessage]!
|
||||
|
||||
"id of the chat"
|
||||
id: ID!
|
||||
}
|
||||
|
||||
type ChatMessage {
|
||||
"The author of the chat message."
|
||||
author: User!
|
||||
|
||||
"The chatroom the message was posted in"
|
||||
chat: ChatRoom!
|
||||
|
||||
"The timestamp when the message was posted (epoch)."
|
||||
createdAt: String!
|
||||
|
||||
"The content of the message."
|
||||
content: String!
|
||||
|
||||
"The content of the message rendered by markdown-it."
|
||||
htmlContent: String
|
||||
}
|
||||
|
||||
"represents the type of vote performed on a post"
|
||||
enum VoteType {
|
||||
UPVOTE
|
||||
DOWNVOTE
|
||||
}
|
||||
|
||||
"""
|
||||
represents the type of request that the user has received
|
||||
Currently on Friend Requests are implemented.
|
||||
"""
|
||||
enum RequestType {
|
||||
FRIENDREQUEST
|
||||
GROUPINVITE
|
||||
EVENTINVITE
|
||||
}
|
@ -0,0 +1,11 @@
|
||||
import App from "./app";
|
||||
|
||||
/**
|
||||
* async main function wrapper.
|
||||
*/
|
||||
(async () => {
|
||||
const app = new App();
|
||||
await app.init();
|
||||
app.start();
|
||||
})();
|
||||
|
@ -0,0 +1,8 @@
|
||||
export enum InternalEvents {
|
||||
CHATCREATE = "chatCreate",
|
||||
CHATMESSAGE = "chatMessage",
|
||||
GQLCHATMESSAGE = "graphqlChatMessage",
|
||||
REQUESTCREATE = "requestCreate",
|
||||
POSTCREATE = "postCreate",
|
||||
GQLPOSTCREATE = "graphqlPostCreate",
|
||||
}
|
@ -0,0 +1,73 @@
|
||||
import * as crypto from "crypto";
|
||||
import {EventEmitter} from "events";
|
||||
|
||||
export class MemoryCache extends EventEmitter {
|
||||
private cacheItems: any = {};
|
||||
private cacheExpires: any = {};
|
||||
private expireCheck: NodeJS.Timeout;
|
||||
|
||||
/**
|
||||
* Creates interval function.
|
||||
* @param ttl
|
||||
*/
|
||||
constructor(private ttl: number = 500) {
|
||||
super();
|
||||
this.expireCheck = setInterval(() => this.checkExpires(), ttl / 2);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a md5 hash of the given key.
|
||||
* @param key
|
||||
*/
|
||||
public hashKey(key: string): string {
|
||||
const hash = crypto.createHash("sha1");
|
||||
const data = hash.update(key, "utf8");
|
||||
return data.digest("hex");
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets an entry.
|
||||
* @param key
|
||||
* @param value
|
||||
*/
|
||||
public set(key: string, value: any) {
|
||||
this.cacheItems[key] = value;
|
||||
this.cacheExpires[key] = Date.now() + this.ttl;
|
||||
this.emit("set", key, value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the entry stored with the given key.
|
||||
* @param key
|
||||
*/
|
||||
public get(key: string) {
|
||||
if (this.cacheItems.hasOwnProperty(key)) {
|
||||
this.emit("hit", key, this.cacheItems[key]);
|
||||
return this.cacheItems[key];
|
||||
} else {
|
||||
this.emit("miss", key);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Deletes a cache item.
|
||||
* @param key
|
||||
*/
|
||||
public delete(key: string) {
|
||||
this.emit("delete", key);
|
||||
delete this.cacheItems[key];
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks expires and clears items that are over the expire value.
|
||||
*/
|
||||
private checkExpires() {
|
||||
for (const [key, value] of Object.entries(this.cacheExpires)) {
|
||||
if (value < Date.now()) {
|
||||
this.emit("delete", key);
|
||||
delete this.cacheItems[key];
|
||||
delete this.cacheExpires[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
@ -0,0 +1,212 @@
|
||||
/**
|
||||
* @author Trivernis
|
||||
* @remarks
|
||||
*
|
||||
* Taken from {@link https://github.com/Trivernis/whooshy}
|
||||
*/
|
||||
|
||||
import * as fsx from "fs-extra";
|
||||
import {Pool, PoolClient, QueryConfig, QueryResult} from "pg";
|
||||
import globals from "./globals";
|
||||
|
||||
const logger = globals.logger;
|
||||
|
||||
export interface IAdvancedQueryConfig extends QueryConfig {
|
||||
cache?: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* Transaction class to wrap SQL transactions.
|
||||
*/
|
||||
export class SqlTransaction {
|
||||
/**
|
||||
* Constructor.
|
||||
* @param client
|
||||
*/
|
||||
constructor(private client: PoolClient) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Begins the transaction.
|
||||
*/
|
||||
public async begin() {
|
||||
return await this.client.query("BEGIN");
|
||||
}
|
||||
|
||||
/**
|
||||
* Commits the transaction
|
||||
*/
|
||||
public async commit() {
|
||||
return await this.client.query("COMMIT");
|
||||
}
|
||||
|
||||
/**
|
||||
* Rolls back the transaction
|
||||
*/
|
||||
public async rollback() {
|
||||
return await this.client.query("ROLLBACK");
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes a query inside the transaction.
|
||||
* @param query
|
||||
*/
|
||||
public async query(query: QueryConfig) {
|
||||
return await this.client.query(query);
|
||||
}
|
||||
|
||||
/**
|
||||
* Releases the client back to the pool.
|
||||
*/
|
||||
public release() {
|
||||
this.client.release();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Query helper for easyer fetching of a specific row count.
|
||||
*/
|
||||
export class QueryHelper {
|
||||
private pool: Pool;
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
* @param pgPool
|
||||
* @param [tableCreationFile]
|
||||
* @param [tableUpdateFile]
|
||||
*/
|
||||
constructor(pgPool: Pool, private tableCreationFile?: string, private tableUpdateFile?: string) {
|
||||
this.pool = pgPool;
|
||||
}
|
||||
|
||||
/**
|
||||
* Async init function
|
||||
*/
|
||||
public async init() {
|
||||
await this.pool.connect();
|
||||
await this.createTables();
|
||||
await this.updateTableDefinitions();
|
||||
}
|
||||
|
||||
/**
|
||||
* creates all tables needed if a filepath was given with the constructor
|
||||
*/
|
||||
public async createTables() {
|
||||
if (this.tableCreationFile) {
|
||||
logger.info("Creating nonexistent tables...");
|
||||
const tableSql = await fsx.readFile(this.tableCreationFile, "utf-8");
|
||||
const trans = await this.createTransaction();
|
||||
await trans.begin();
|
||||
try {
|
||||
await trans.query({text: tableSql});
|
||||
await trans.commit();
|
||||
} catch (err) {
|
||||
globals.logger.error(`Error on table creation ${err.message}`);
|
||||
globals.logger.debug(err.stack);
|
||||
await trans.rollback();
|
||||
} finally {
|
||||
trans.release();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the definition of the tables if the table update file was passed in the constructor
|
||||
*/
|
||||
public async updateTableDefinitions() {
|
||||
if (this.tableUpdateFile) {
|
||||
logger.info("Updating table definitions...");
|
||||
const tableSql = await fsx.readFile(this.tableUpdateFile, "utf-8");
|
||||
const trans = await this.createTransaction();
|
||||
await trans.begin();
|
||||
try {
|
||||
await trans.query({text: tableSql});
|
||||
await trans.commit();
|
||||
} catch (err) {
|
||||
globals.logger.error(`Error on table update ${err.message}`);
|
||||
globals.logger.debug(err.stack);
|
||||
await trans.rollback();
|
||||
} finally {
|
||||
trans.release();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* executes the sql query with values and returns all results.
|
||||
* @param query
|
||||
*/
|
||||
public async all(query: IAdvancedQueryConfig): Promise<any[]> {
|
||||
const result = await this.query(query);
|
||||
return result.rows;
|
||||
}
|
||||
|
||||
/**
|
||||
* executes the sql query with values and returns the first result.
|
||||
* @param query
|
||||
*/
|
||||
public async first(query: IAdvancedQueryConfig): Promise<any> {
|
||||
const result = await this.query(query);
|
||||
if (result.rows && result.rows.length > 0) {
|
||||
return result.rows[0];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new Transaction to be uses with error handling.
|
||||
*/
|
||||
public async createTransaction() {
|
||||
const client: PoolClient = await this.pool.connect();
|
||||
return new SqlTransaction(client);
|
||||
}
|
||||
|
||||
/**
|
||||
* Queries the database with error handling.
|
||||
* @param query - the sql and values to execute
|
||||
*/
|
||||
private async query(query: IAdvancedQueryConfig): Promise<QueryResult|{rows: any}> {
|
||||
try {
|
||||
query.text = query.text.replace(/[\r\n]/g, " ");
|
||||
globals.logger.silly(`Executing sql '${JSON.stringify(query)}'`);
|
||||
|
||||
if (query.cache) {
|
||||
const key = globals.cache.hashKey(JSON.stringify(query));
|
||||
const cacheResult = globals.cache.get(key);
|
||||
if (cacheResult) {
|
||||
return cacheResult;
|
||||
} else {
|
||||
const result = await this.pool.query(query);
|
||||
globals.cache.set(key, result);
|
||||
return result;
|
||||
}
|
||||
} else {
|
||||
return await this.pool.query(query);
|
||||
}
|
||||
} catch (err) {
|
||||
logger.debug(`Error on query "${JSON.stringify(query)}".`);
|
||||
logger.error(`Sql query failed: ${err}`);
|
||||
logger.verbose(err.stack);
|
||||
return {
|
||||
rows: null,
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the parameterized value sql for inserting
|
||||
* @param columnCount
|
||||
* @param rowCount
|
||||
* @param [offset]
|
||||
*/
|
||||
export function buildSqlParameters(columnCount: number, rowCount: number, offset?: number): string {
|
||||
let sql = "";
|
||||
for (let i = 0; i < rowCount; i++) {
|
||||
sql += "(";
|
||||
for (let j = 0; j < columnCount; j++) {
|
||||
sql += `$${(i * columnCount) + j + 1 + offset},`;
|
||||
}
|
||||
sql = sql.replace(/,$/, "") + "),";
|
||||
}
|
||||
return sql.replace(/,$/, "");
|
||||
}
|
@ -0,0 +1,26 @@
|
||||
/**
|
||||
* @author Trivernis
|
||||
* @remarks
|
||||
*
|
||||
* Taken from {@link https://github.com/Trivernis/whooshy}
|
||||
*/
|
||||
|
||||
import {Router} from "express";
|
||||
import {Namespace, Server} from "socket.io";
|
||||
|
||||
/**
|
||||
* Abstract Route class to be implemented by each route.
|
||||
* This class contains the socket-io Server, router and resolver
|
||||
* for each route.
|
||||
*/
|
||||
abstract class Route {
|
||||
|
||||
public router?: Router;
|
||||
protected io?: Server;
|
||||
protected ions?: Namespace;
|
||||
|
||||
public abstract async init(...params: any): Promise<any>;
|
||||
public abstract async destroy(...params: any): Promise<any>;
|
||||
}
|
||||
|
||||
export default Route;
|
@ -0,0 +1,31 @@
|
||||
import markdown from "../markdown";
|
||||
import {Chatroom} from "./Chatroom";
|
||||
import {User} from "./User";
|
||||
|
||||
export class ChatMessage {
|
||||
constructor(
|
||||
public readonly author: User,
|
||||
public readonly chat: Chatroom,
|
||||
public readonly createdAt: number,
|
||||
public readonly content: string) {}
|
||||
|
||||
/**
|
||||
* The content rendered by markdown-it.
|
||||
*/
|
||||
public htmlContent(): string {
|
||||
return markdown.renderInline(this.content);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns resolved and rendered content of the chat message.
|
||||
*/
|
||||
public resolvedContent() {
|
||||
return {
|
||||
author: this.author.id,
|
||||
chat: this.chat.id,
|
||||
content: this.content,
|
||||
createdAt: this.createdAt,
|
||||
htmlContent: this.htmlContent(),
|
||||
};
|
||||
}
|
||||
}
|
@ -0,0 +1,76 @@
|
||||
import globals from "../globals";
|
||||
import {ChatMessage} from "./ChatMessage";
|
||||
import {queryHelper} from "./index";
|
||||
import {User} from "./User";
|
||||
|
||||
export class Chatroom {
|
||||
|
||||
public namespace: string;
|
||||
constructor(public readonly id: number) {
|
||||
this.id = Number(id);
|
||||
this.namespace = `/chat/${id}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns if the chat exists.
|
||||
*/
|
||||
public async exists(): Promise<boolean> {
|
||||
const result = await queryHelper.first({
|
||||
text: "SELECT id FROM chats WHERE id = $1",
|
||||
values: [this.id],
|
||||
});
|
||||
return !!result.id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all members of a chatroom.
|
||||
*/
|
||||
public async members(): Promise<User[]> {
|
||||
const result = await queryHelper.all({
|
||||
cache: true,
|
||||
text: `SELECT * FROM chat_members
|
||||
JOIN users ON (chat_members.member = users.id)
|
||||
WHERE chat_members.chat = $1;`,
|
||||
values: [this.id],
|
||||
});
|
||||
const chatMembers = [];
|
||||
for (const row of result) {
|
||||
const user = new User(row.id, row);
|
||||
chatMembers.push(user);
|
||||
}
|
||||
return chatMembers;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns messages of the chat
|
||||
* @param limit - the limit of messages to return
|
||||
* @param offset - the offset of messages to return
|
||||
* @param containing - filter by containing
|
||||
*/
|
||||
public async messages({first, offset, containing}: {first?: number, offset?: number, containing?: string}) {
|
||||
const lim = first || 16;
|
||||
const offs = offset || 0;
|
||||
|
||||
const result = await queryHelper.all({
|
||||
cache: true,
|
||||
text: "SELECT * FROM chat_messages WHERE chat = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3",
|
||||
values: [this.id, lim, offs],
|
||||
});
|
||||
|
||||
const messages = [];
|
||||
const users: any = {};
|
||||
for (const row of result) {
|
||||
if (!users[row.author]) {
|
||||
const user = new User(row.author);
|
||||
await user.exists();
|
||||
users[row.author] = user;
|
||||
}
|
||||
messages.push(new ChatMessage(users[row.author], this, row.created_at, row.content));
|
||||
}
|
||||
if (containing) {
|
||||
return messages.filter((x) => x.content.includes(containing));
|
||||
} else {
|
||||
return messages;
|
||||
}
|
||||
}
|
||||
}
|
@ -0,0 +1,40 @@
|
||||
/**
|
||||
* abstact DataObject class
|
||||
*/
|
||||
import {EventEmitter} from "events";
|
||||
|
||||
export abstract class DataObject extends EventEmitter {
|
||||
protected dataLoaded: boolean = false;
|
||||
private loadingData: boolean = false;
|
||||
|
||||
constructor(public id: number, protected row?: any) {
|
||||
super();
|
||||
this.id = Number(id);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns if the object extists by trying to load data.
|
||||
*/
|
||||
public async exists() {
|
||||
await this.loadDataIfNotExists();
|
||||
return this.dataLoaded;
|
||||
}
|
||||
|
||||
protected abstract loadData(): Promise<void>;
|
||||
|
||||
/**
|
||||
* Loads data from the database if data has not been loaded
|
||||
*/
|
||||
protected async loadDataIfNotExists() {
|
||||
if (!this.dataLoaded && !this.loadingData) {
|
||||
this.loadingData = true;
|
||||
await this.loadData();
|
||||
this.loadingData = false;
|
||||
this.emit("loaded");
|
||||
} else if (this.loadingData) {
|
||||
return new Promise((res) => {
|
||||
this.on("loaded", () => res());
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
@ -0,0 +1,159 @@
|
||||
import markdown from "../markdown";
|
||||
import {DataObject} from "./DataObject";
|
||||
import {queryHelper} from "./index";
|
||||
import dataaccess from "./index";
|
||||
import {User} from "./User";
|
||||
|
||||
export class Post extends DataObject {
|
||||
public readonly id: number;
|
||||
private $createdAt: string;
|
||||
private $content: string;
|
||||
private $author: number;
|
||||
private $type: string;
|
||||
|
||||
/**
|
||||
* Returns the resolved data of the post.
|
||||
*/
|
||||
public async resolvedData() {
|
||||
await this.loadDataIfNotExists();
|
||||
return {
|
||||
authorId: this.$author,
|
||||
content: this.$content,
|
||||
createdAt: this.$createdAt,
|
||||
id: this.id,
|
||||
type: this.$type,
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Returns the upvotes of a post.
|
||||
*/
|
||||
public async upvotes(): Promise<number> {
|
||||
const result = await queryHelper.first({
|
||||
cache: true,
|
||||
text: "SELECT COUNT(*) count FROM votes WHERE item_id = $1 AND vote_type = 'UPVOTE'",
|
||||
values: [this.id],
|
||||
});
|
||||
return result.count;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the downvotes of the post
|
||||
*/
|
||||
public async downvotes(): Promise<number> {
|
||||
const result = await queryHelper.first({
|
||||
cache: true,
|
||||
text: "SELECT COUNT(*) count FROM votes WHERE item_id = $1 AND vote_type = 'DOWNVOTE'",
|
||||
values: [this.id],
|
||||
});
|
||||
return result.count;
|
||||
}
|
||||
|
||||
/**
|
||||
* The content of the post (markdown)
|
||||
*/
|
||||
public async content(): Promise<string> {
|
||||
await this.loadDataIfNotExists();
|
||||
return this.$content;
|
||||
}
|
||||
|
||||
/**
|
||||
* the content rendered by markdown-it.
|
||||
*/
|
||||
public async htmlContent(): Promise<string> {
|
||||
await this.loadDataIfNotExists();
|
||||
return markdown.render(this.$content);
|
||||
}
|
||||
|
||||
/**
|
||||
* The date the post was created at.
|
||||
*/
|
||||
public async createdAt(): Promise<string> {
|
||||
await this.loadDataIfNotExists();
|
||||
return this.$createdAt;
|
||||
}
|
||||
|
||||
/**
|
||||
* The autor of the post.
|
||||
*/
|
||||
public async author(): Promise<User> {
|
||||
await this.loadDataIfNotExists();
|
||||
return new User(this.$author);
|
||||
}
|
||||
|
||||
/**
|
||||
* Deletes the post.
|
||||
*/
|
||||
public async delete(): Promise<void> {
|
||||
const query = await queryHelper.first({
|
||||
text: "DELETE FROM posts WHERE id = $1",
|
||||
values: [this.id],
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* The type of vote the user performed on the post.
|
||||
*/
|
||||
public async userVote(userId: number): Promise<dataaccess.VoteType> {
|
||||
const result = await queryHelper.first({
|
||||
cache: true,
|
||||
text: "SELECT vote_type FROM votes WHERE user_id = $1 AND item_id = $2",
|
||||
values: [userId, this.id],
|
||||
});
|
||||
if (result) {
|
||||
return result.vote_type;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs a vote on a post.
|
||||
* @param userId
|
||||
* @param type
|
||||
*/
|
||||
public async vote(userId: number, type: dataaccess.VoteType): Promise<dataaccess.VoteType> {
|
||||
const uVote = await this.userVote(userId);
|
||||
if (uVote === type) {
|
||||
await queryHelper.first({
|
||||
text: "DELETE FROM votes WHERE item_id = $1 AND user_id = $2",
|
||||
values: [this.id, userId],
|
||||
});
|
||||
} else {
|
||||
if (uVote) {
|
||||
await queryHelper.first({
|
||||
text: "UPDATE votes SET vote_type = $1 WHERE user_id = $2 AND item_id = $3",
|
||||
values: [type, userId, this.id],
|
||||
});
|
||||
} else {
|
||||
await queryHelper.first({
|
||||
text: "INSERT INTO votes (user_id, item_id, vote_type) values ($1, $2, $3)",
|
||||
values: [userId, this.id, type],
|
||||
});
|
||||
}
|
||||
return type;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads the data from the database if needed.
|
||||
*/
|
||||
protected async loadData(): Promise<void> {
|
||||
let result: any;
|
||||
if (this.row) {
|
||||
result = this.row;
|
||||
} else {
|
||||
result = await queryHelper.first({
|
||||
cache: true,
|
||||
text: "SELECT * FROM posts WHERE posts.id = $1",
|
||||
values: [this.id],
|
||||
});
|
||||
}
|
||||
if (result) {
|
||||
this.$author = result.author;
|
||||
this.$content = result.content;
|
||||
this.$createdAt = result.created_at;
|
||||
this.$type = result.type;
|
||||
this.dataLoaded = true;
|
||||
}
|
||||
}
|
||||
}
|
@ -0,0 +1,163 @@
|
||||
import {RequestNotFoundError} from "../errors/RequestNotFoundError";
|
||||
import {Chatroom} from "./Chatroom";
|
||||
import dataaccess, {queryHelper} from "./index";
|
||||
import {User} from "./User";
|
||||
import {Request} from "./Request";
|
||||
|
||||
export class Profile extends User {
|
||||
|
||||
/**
|
||||
* Returns all chatrooms (with pagination).
|
||||
* Skips the query if the user doesn't exist.
|
||||
* @param first
|
||||
* @param offset
|
||||
*/
|
||||
public async chats({first, offset}: {first: number, offset?: number}): Promise<Chatroom[]> {
|
||||
if (!(await this.exists())) {
|
||||
return [];
|
||||
}
|
||||
first = first || 10;
|
||||
offset = offset || 0;
|
||||
|
||||
const result = await queryHelper.all({
|
||||
text: "SELECT chat FROM chat_members WHERE member = $1 LIMIT $2 OFFSET $3",
|
||||
values: [this.id, first, offset],
|
||||
});
|
||||
if (result) {
|
||||
return result.map((row) => new Chatroom(row.chat));
|
||||
} else {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all open requests the user has send.
|
||||
*/
|
||||
public async sentRequests() {
|
||||
const result = await queryHelper.all({
|
||||
cache: true,
|
||||
text: "SELECT * FROM requests WHERE sender = $1",
|
||||
values: [this.id],
|
||||
});
|
||||
return this.getRequests(result);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all received requests of the user.
|
||||
*/
|
||||
public async receivedRequests() {
|
||||
const result = await queryHelper.all({
|
||||
cache: true,
|
||||
text: "SELECT * FROM requests WHERE receiver = $1",
|
||||
values: [this.id],
|
||||
});
|
||||
return this.getRequests(result);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the greenpoints of a user.
|
||||
* @param points
|
||||
*/
|
||||
public async setGreenpoints(points: number): Promise<number> {
|
||||
const result = await queryHelper.first({
|
||||
text: "UPDATE users SET greenpoints = $1 WHERE id = $2 RETURNING greenpoints",
|
||||
values: [points, this.id],
|
||||
});
|
||||
return result.greenpoints;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the email of the user
|
||||
* @param email
|
||||
*/
|
||||
public async setEmail(email: string): Promise<string> {
|
||||
const result = await queryHelper.first({
|
||||
text: "UPDATE users SET email = $1 WHERE users.id = $2 RETURNING email",
|
||||
values: [email, this.id],
|
||||
});
|
||||
return result.email;
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates the handle of the user
|
||||
*/
|
||||
public async setHandle(handle: string): Promise<string> {
|
||||
const result = await queryHelper.first({
|
||||
text: "UPDATE users SET handle = $1 WHERE id = $2",
|
||||
values: [handle, this.id],
|
||||
});
|
||||
return result.handle;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the username of the user
|
||||
* @param name
|
||||
*/
|
||||
public async setName(name: string): Promise<string> {
|
||||
const result = await queryHelper.first({
|
||||
text: "UPDATE users SET name = $1 WHERE id = $2",
|
||||
values: [name, this.id],
|
||||
});
|
||||
return result.name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Denys a request.
|
||||
* @param sender
|
||||
* @param type
|
||||
*/
|
||||
public async denyRequest(sender: number, type: dataaccess.RequestType) {
|
||||
await queryHelper.first({
|
||||
text: "DELETE FROM requests WHERE receiver = $1 AND sender = $2 AND type = $3",
|
||||
values: [this.id, sender, type],
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Accepts a request.
|
||||
* @param sender
|
||||
* @param type
|
||||
*/
|
||||
public async acceptRequest(sender: number, type: dataaccess.RequestType) {
|
||||
const exists = await queryHelper.first({
|
||||
cache: true,
|
||||
text: "SELECT 1 FROM requests WHERE receiver = $1 AND sender = $2 AND type = $3",
|
||||
values: [this.id, sender, type],
|
||||
});
|
||||
if (exists) {
|
||||
if (type === dataaccess.RequestType.FRIENDREQUEST) {
|
||||
await queryHelper.first({
|
||||
text: "INSERT INTO user_friends (user_id, friend_id) VALUES ($1, $2)",
|
||||
values: [this.id, sender],
|
||||
});
|
||||
}
|
||||
} else {
|
||||
throw new RequestNotFoundError(sender, this.id, type);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns request wrapper for a row database request result.
|
||||
* @param rows
|
||||
*/
|
||||
private getRequests(rows: any) {
|
||||
const requests = [];
|
||||
const requestUsers: any = {};
|
||||
|
||||
for (const row of rows) {
|
||||
let sender = requestUsers[row.sender];
|
||||
|
||||
if (!sender) {
|
||||
sender = new User(row.sender);
|
||||
requestUsers[row.sender] = sender;
|
||||
}
|
||||
let receiver = requestUsers[row.receiver];
|
||||
if (!receiver) {
|
||||
receiver = new User(row.receiver);
|
||||
requestUsers[row.receiver] = receiver;
|
||||
}
|
||||
requests.push(new Request(sender, receiver, row.type));
|
||||
}
|
||||
return requests;
|
||||
}
|
||||
}
|
@ -0,0 +1,24 @@
|
||||
import dataaccess from "./index";
|
||||
import {User} from "./User";
|
||||
|
||||
/**
|
||||
* Represents a request to a user.
|
||||
*/
|
||||
export class Request {
|
||||
constructor(
|
||||
public readonly sender: User,
|
||||
public readonly receiver: User,
|
||||
public readonly type: dataaccess.RequestType) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the resolved request data.
|
||||
*/
|
||||
public resolvedData() {
|
||||
return {
|
||||
receiverId: this.receiver.id,
|
||||
senderId: this.sender.id,
|
||||
type: this.type,
|
||||
};
|
||||
}
|
||||
}
|
@ -0,0 +1,128 @@
|
||||
import globals from "../globals";
|
||||
import {DataObject} from "./DataObject";
|
||||
import {queryHelper} from "./index";
|
||||
import {Post} from "./Post";
|
||||
|
||||
export class User extends DataObject {
|
||||
private $name: string;
|
||||
private $handle: string;
|
||||
private $email: string;
|
||||
private $greenpoints: number;
|
||||
private $joinedAt: string;
|
||||
private $exists: boolean;
|
||||
|
||||
/**
|
||||
* The name of the user
|
||||
*/
|
||||
public async name(): Promise<string> {
|
||||
await this.loadDataIfNotExists();
|
||||
return this.$name;
|
||||
}
|
||||
|
||||
/**
|
||||
* The unique handle of the user.
|
||||
*/
|
||||
public async handle(): Promise<string> {
|
||||
await this.loadDataIfNotExists();
|
||||
return this.$handle;
|
||||
}
|
||||
|
||||
/**
|
||||
* The email of the user
|
||||
*/
|
||||
public async email(): Promise<string> {
|
||||
await this.loadDataIfNotExists();
|
||||
return this.$email;
|
||||
}
|
||||
|
||||
/**
|
||||
* The number of greenpoints of the user
|
||||
*/
|
||||
public async greenpoints(): Promise<number> {
|
||||
await this.loadDataIfNotExists();
|
||||
return this.$greenpoints;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the number of posts the user created
|
||||
*/
|
||||
public async numberOfPosts(): Promise<number> {
|
||||
const result = await queryHelper.first({
|
||||
cache: true,
|
||||
text: "SELECT COUNT(*) count FROM posts WHERE author = $1",
|
||||
values: [this.id],
|
||||
});
|
||||
return result.count;
|
||||
}
|
||||
|
||||
/**
|
||||
* The date the user joined the platform
|
||||
*/
|
||||
public async joinedAt(): Promise<Date> {
|
||||
await this.loadDataIfNotExists();
|
||||
return new Date(this.$joinedAt);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all friends of the user.
|
||||
*/
|
||||
public async friends(): Promise<User[]> {
|
||||
const result = await queryHelper.all({
|
||||
cache: true,
|
||||
text: "SELECT * FROM user_friends WHERE user_id = $1 OR friend_id = $1",
|
||||
values: [this.id],
|
||||
});
|
||||
const userFriends = [];
|
||||
for (const row of result) {
|
||||
if (row.user_id === this.id) {
|
||||
userFriends.push(new User(row.friend_id));
|
||||
} else {
|
||||
userFriends.push(new User(row.user_id));
|
||||
}
|
||||
}
|
||||
return userFriends;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all posts for a user.
|
||||
*/
|
||||
public async posts({first, offset}: {first: number, offset: number}): Promise<Post[]> {
|
||||
first = first || 10;
|
||||
offset = offset || 0;
|
||||
const result = await queryHelper.all({
|
||||
cache: true,
|
||||
text: "SELECT * FROM posts WHERE author = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3",
|
||||
values: [this.id, first, offset],
|
||||
});
|
||||
const posts = [];
|
||||
|
||||
for (const row of result) {
|
||||
posts.push(new Post(row.id, row));
|
||||
}
|
||||
return posts;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetches the data for the user.
|
||||
*/
|
||||
protected async loadData(): Promise<void> {
|
||||
let result: any;
|
||||
if (this.row) {
|
||||
result = this.row;
|
||||
} else {
|
||||
result = await queryHelper.first({
|
||||
cache: true,
|
||||
text: "SELECT * FROM users WHERE users.id = $1",
|
||||
values: [this.id],
|
||||
});
|
||||
}
|
||||
if (result) {
|
||||
this.$name = result.name;
|
||||
this.$handle = result.handle;
|
||||
this.$email = result.email;
|
||||
this.$greenpoints = result.greenpoints;
|
||||
this.$joinedAt = result.joined_at;
|
||||
this.dataLoaded = true;
|
||||
}
|
||||
}
|
||||
}
|
@ -0,0 +1,258 @@
|
||||
import {Pool} from "pg";
|
||||
import {ChatNotFoundError} from "../errors/ChatNotFoundError";
|
||||
import {EmailAlreadyRegisteredError} from "../errors/EmailAlreadyRegisteredError";
|
||||
import {UserNotFoundError} from "../errors/UserNotFoundError";
|
||||
import globals from "../globals";
|
||||
import {InternalEvents} from "../InternalEvents";
|
||||
import {QueryHelper} from "../QueryHelper";
|
||||
import {ChatMessage} from "./ChatMessage";
|
||||
import {Chatroom} from "./Chatroom";
|
||||
import {Post} from "./Post";
|
||||
import {Profile} from "./Profile";
|
||||
import {Request} from "./Request";
|
||||
import {User} from "./User";
|
||||
|
||||
const config = globals.config;
|
||||
const tableCreationFile = __dirname + "/../../sql/create-tables.sql";
|
||||
const tableUpdateFile = __dirname + "/../../sql/update-tables.sql";
|
||||
|
||||
const dbClient: Pool = new Pool({
|
||||
database: config.database.database,
|
||||
host: config.database.host,
|
||||
password: config.database.password,
|
||||
port: config.database.port,
|
||||
user: config.database.user,
|
||||
});
|
||||
export const queryHelper = new QueryHelper(dbClient, tableCreationFile, tableUpdateFile);
|
||||
|
||||
/**
|
||||
* Generates a new handle from the username and a base64 string of the current time.
|
||||
* @param username
|
||||
*/
|
||||
function generateHandle(username: string) {
|
||||
return `${username}.${Buffer.from(Date.now().toString()).toString("base64")}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Namespace with functions to fetch initial data for wrapping.
|
||||
*/
|
||||
namespace dataaccess {
|
||||
|
||||
export const pool: Pool = dbClient;
|
||||
|
||||
/**
|
||||
* Initializes everything that needs to be initialized asynchronous.
|
||||
*/
|
||||
export async function init() {
|
||||
try {
|
||||
await queryHelper.init();
|
||||
} catch (err) {
|
||||
globals.logger.error(err.message);
|
||||
globals.logger.debug(err.stack);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the user by handle.
|
||||
* @param userHandle
|
||||
*/
|
||||
export async function getUserByHandle(userHandle: string): Promise<User> {
|
||||
const result = await queryHelper.first({
|
||||
text: "SELECT * FROM users WHERE users.handle = $1",
|
||||
values: [userHandle],
|
||||
});
|
||||
if (result) {
|
||||
return new User(result.id, result);
|
||||
} else {
|
||||
throw new UserNotFoundError(userHandle);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the user by email and password
|
||||
* @param email
|
||||
* @param password
|
||||
*/
|
||||
export async function getUserByLogin(email: string, password: string): Promise<Profile> {
|
||||
const result = await queryHelper.first({
|
||||
text: "SELECT * FROM users WHERE email = $1 AND password = $2",
|
||||
values: [email, password],
|
||||
});
|
||||
if (result) {
|
||||
return new Profile(result.id, result);
|
||||
} else {
|
||||
throw new UserNotFoundError(email);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a user with a username and password returning a user
|
||||
* @param username
|
||||
* @param email
|
||||
* @param password
|
||||
*/
|
||||
export async function registerUser(username: string, email: string, password: string) {
|
||||
const existResult = await queryHelper.first({
|
||||
text: "SELECT email FROM users WHERE email = $1;",
|
||||
values: [email],
|
||||
});
|
||||
if (!existResult || !existResult.email) {
|
||||
const result = await queryHelper.first({
|
||||
text: "INSERT INTO users (name, handle, password, email) VALUES ($1, $2, $3, $4) RETURNING *",
|
||||
values: [username, generateHandle(username), password, email],
|
||||
});
|
||||
return new Profile(result.id, result);
|
||||
} else {
|
||||
throw new EmailAlreadyRegisteredError(email);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a post for a given postId.s
|
||||
* @param postId
|
||||
*/
|
||||
export async function getPost(postId: number): Promise<Post> {
|
||||
const result = await queryHelper.first({
|
||||
text: "SELECT * FROM posts WHERE id = $1",
|
||||
values: [postId],
|
||||
});
|
||||
if (result) {
|
||||
return new Post(result.id, result);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a post
|
||||
* @param content
|
||||
* @param authorId
|
||||
* @param type
|
||||
*/
|
||||
export async function createPost(content: string, authorId: number, type?: string): Promise<Post> {
|
||||
type = type || "MISC";
|
||||
const result = await queryHelper.first({
|
||||
text: "INSERT INTO posts (content, author, type) VALUES ($1, $2, $3) RETURNING *",
|
||||
values: [content, authorId, type],
|
||||
});
|
||||
const post = new Post(result.id, result);
|
||||
globals.internalEmitter.emit(InternalEvents.POSTCREATE, post);
|
||||
return post;
|
||||
}
|
||||
|
||||
/**
|
||||
* Deletes a post
|
||||
* @param postId
|
||||
*/
|
||||
export async function deletePost(postId: number): Promise<boolean> {
|
||||
const result = await queryHelper.first({
|
||||
text: "DELETE FROM posts WHERE posts.id = $1",
|
||||
values: [postId],
|
||||
});
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a chatroom containing two users
|
||||
* @param members
|
||||
*/
|
||||
export async function createChat(...members: number[]): Promise<Chatroom> {
|
||||
const idResult = await queryHelper.first({
|
||||
text: "INSERT INTO chats (id) values (default) RETURNING *;",
|
||||
});
|
||||
const id = idResult.id;
|
||||
const transaction = await queryHelper.createTransaction();
|
||||
try {
|
||||
await transaction.begin();
|
||||
for (const member of members) {
|
||||
await transaction.query({
|
||||
name: "chat-member-insert",
|
||||
text: "INSERT INTO chat_members (chat, member) VALUES ($1, $2);",
|
||||
values: [id, member],
|
||||
});
|
||||
}
|
||||
await transaction.commit();
|
||||
} catch (err) {
|
||||
globals.logger.warn(`Failed to insert chatmember into database: ${err.message}`);
|
||||
globals.logger.debug(err.stack);
|
||||
await transaction.rollback();
|
||||
} finally {
|
||||
transaction.release();
|
||||
}
|
||||
const chat = new Chatroom(id);
|
||||
globals.internalEmitter.emit(InternalEvents.CHATCREATE, chat);
|
||||
return chat;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends a message into a chat.
|
||||
* @param authorId
|
||||
* @param chatId
|
||||
* @param content
|
||||
*/
|
||||
export async function sendChatMessage(authorId: number, chatId: number, content: string) {
|
||||
const chat = new Chatroom(chatId);
|
||||
if ((await chat.exists())) {
|
||||
const result = await queryHelper.first({
|
||||
text: "INSERT INTO chat_messages (chat, author, content) values ($1, $2, $3) RETURNING *",
|
||||
values: [chatId, authorId, content],
|
||||
});
|
||||
const message = new ChatMessage(new User(result.author), chat, result.created_at, result.content);
|
||||
globals.internalEmitter.emit(InternalEvents.CHATMESSAGE, message);
|
||||
return message;
|
||||
} else {
|
||||
throw new ChatNotFoundError(chatId);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all chats.
|
||||
*/
|
||||
export async function getAllChats(): Promise<Chatroom[]> {
|
||||
const result = await queryHelper.all({
|
||||
text: "SELECT id FROM chats;",
|
||||
});
|
||||
const chats = [];
|
||||
for (const row of result) {
|
||||
chats.push(new Chatroom(row.id));
|
||||
}
|
||||
return chats;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends a request to a user.
|
||||
* @param sender
|
||||
* @param receiver
|
||||
* @param type
|
||||
*/
|
||||
export async function createRequest(sender: number, receiver: number, type?: RequestType) {
|
||||
type = type || RequestType.FRIENDREQUEST;
|
||||
|
||||
const result = await queryHelper.first({
|
||||
text: "INSERT INTO requests (sender, receiver, type) VALUES ($1, $2, $3) RETURNING *",
|
||||
values: [sender, receiver, type],
|
||||
});
|
||||
const request = new Request(new User(result.sender), new User(result.receiver), result.type);
|
||||
globals.internalEmitter.emit(InternalEvents.REQUESTCREATE, Request);
|
||||
return request;
|
||||
}
|
||||
|
||||
/**
|
||||
* Enum representing the types of votes that can be performed on a post.
|
||||
*/
|
||||
export enum VoteType {
|
||||
UPVOTE = "UPVOTE",
|
||||
DOWNVOTE = "DOWNVOTE",
|
||||
}
|
||||
|
||||
/**
|
||||
* Enum representing the types of request that can be created.
|
||||
*/
|
||||
export enum RequestType {
|
||||
FRIENDREQUEST = "FRIENDREQUEST",
|
||||
GROUPINVITE = "GROUPINVITE",
|
||||
EVENTINVITE = "EVENTINVITE",
|
||||
}
|
||||
}
|
||||
|
||||
export default dataaccess;
|
@ -0,0 +1,13 @@
|
||||
import {GraphQLError} from "graphql";
|
||||
|
||||
/**
|
||||
* Base error class.
|
||||
*/
|
||||
export class BaseError extends Error {
|
||||
public readonly graphqlError: GraphQLError;
|
||||
|
||||
constructor(message?: string, friendlyMessage?: string) {
|
||||
super(message);
|
||||
this.graphqlError = new GraphQLError(friendlyMessage || message);
|
||||
}
|
||||
}
|
@ -0,0 +1,7 @@
|
||||
import {BaseError} from "./BaseError";
|
||||
|
||||
export class ChatNotFoundError extends BaseError {
|
||||
constructor(chatId: number) {
|
||||
super(`Chat with id ${chatId} not found.`);
|
||||
}
|
||||
}
|
@ -0,0 +1,8 @@
|
||||
import {BaseError} from "./BaseError";
|
||||
|
||||
export class EmailAlreadyRegisteredError extends BaseError {
|
||||
constructor(email: string) {
|
||||
super(`A user for '${email}' does already exist.`);
|
||||
}
|
||||
|
||||
}
|
@ -0,0 +1,9 @@
|
||||
import dataaccess from "../dataaccess";
|
||||
import {BaseError} from "./BaseError";
|
||||
|
||||
export class RequestNotFoundError extends BaseError {
|
||||
constructor(sender: number, receiver: number, type: dataaccess.RequestType) {
|
||||
super(`Request with sender '${sender}' and receiver '${receiver}' of type '${type}' not found.`);
|
||||
}
|
||||
|
||||
}
|
@ -0,0 +1,7 @@
|
||||
import {BaseError} from "./BaseError";
|
||||
|
||||
export class UserNotFoundError extends BaseError {
|
||||
constructor(username: string) {
|
||||
super(`User ${username} not found!`);
|
||||
}
|
||||
}
|
@ -0,0 +1,9 @@
|
||||
import {GraphQLError} from "graphql";
|
||||
import {BaseError} from "./BaseError";
|
||||
|
||||
export class NotLoggedInGqlError extends GraphQLError {
|
||||
|
||||
constructor() {
|
||||
super("Not logged in");
|
||||
}
|
||||
}
|
@ -0,0 +1,52 @@
|
||||
/**
|
||||
* @author Trivernis
|
||||
* @remarks
|
||||
*
|
||||
* Partly taken from {@link https://github.com/Trivernis/whooshy}
|
||||
*/
|
||||
|
||||
import {EventEmitter} from "events";
|
||||
import * as fsx from "fs-extra";
|
||||
import * as yaml from "js-yaml";
|
||||
import * as winston from "winston";
|
||||
import {MemoryCache} from "./MemoryCache";
|
||||
|
||||
const configPath = "config.yaml";
|
||||
const defaultConfig = __dirname + "/../default-config.yaml";
|
||||
|
||||
// ensure that the config exists by copying the default config.
|
||||
if (!(fsx.pathExistsSync(configPath))) {
|
||||
fsx.copySync(defaultConfig, configPath);
|
||||
} else {
|
||||
const conf = yaml.safeLoad(fsx.readFileSync(configPath, "utf-8"));
|
||||
const defConf = yaml.safeLoad(fsx.readFileSync(defaultConfig, "utf-8"));
|
||||
fsx.writeFileSync(configPath, yaml.safeDump(Object.assign(defConf, conf)));
|
||||
}
|
||||
|
||||
/**
|
||||
* Defines global variables to be used.
|
||||
*/
|
||||
namespace globals {
|
||||
export const config = yaml.safeLoad(fsx.readFileSync("config.yaml", "utf-8"));
|
||||
export const cache = new MemoryCache(1200);
|
||||
export const logger = winston.createLogger({
|
||||
transports: [
|
||||
new winston.transports.Console({
|
||||
format: winston.format.combine(
|
||||
winston.format.timestamp(),
|
||||
winston.format.colorize(),
|
||||
winston.format.printf(({ level, message, timestamp }) => {
|
||||
return `${timestamp} ${level}: ${message}`;
|
||||
}),
|
||||
),
|
||||
level: config.logging.level,
|
||||
}),
|
||||
],
|
||||
});
|
||||
export const internalEmitter = new EventEmitter();
|
||||
cache.on("set", (key) => logger.debug(`Caching '${key}'.`));
|
||||
cache.on("miss", (key) => logger.debug(`Cache miss for '${key}'`));
|
||||
cache.on("hit", (key) => logger.debug(`Cache hit for '${key}'`));
|
||||
}
|
||||
|
||||
export default globals;
|
@ -0,0 +1,36 @@
|
||||
import * as MarkdownIt from "markdown-it/lib";
|
||||
import globals from "./globals";
|
||||
|
||||
namespace markdown {
|
||||
|
||||
const md = new MarkdownIt();
|
||||
|
||||
for (const pluginName of globals.config.markdown.plugins) {
|
||||
try {
|
||||
const plugin = require(pluginName);
|
||||
if (plugin) {
|
||||
md.use(plugin);
|
||||
}
|
||||
} catch (err) {
|
||||
globals.logger.warn(`Markdown-it plugin '${pluginName}' not found!`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Renders the markdown string inline (without blocks).
|
||||
* @param markdownString
|
||||
*/
|
||||
export function renderInline(markdownString: string) {
|
||||
return md.renderInline(markdownString);
|
||||
}
|
||||
|
||||
/**
|
||||
* Renders the markdown string.
|
||||
* @param markdownString
|
||||
*/
|
||||
export function render(markdownString: string) {
|
||||
return md.render(markdownString);
|
||||
}
|
||||
}
|
||||
|
||||
export default markdown;
|
@ -0,0 +1,11 @@
|
||||
export namespace is {
|
||||
const emailRegex = /\S+?@\S+?(\.\S+?)?\.\w{2,3}(.\w{2-3})?/g;
|
||||
|
||||
/**
|
||||
* Tests if a string is a valid email.
|
||||
* @param testString
|
||||
*/
|
||||
export function email(testString: string) {
|
||||
return emailRegex.test(testString);
|
||||
}
|
||||
}
|
@ -0,0 +1,5 @@
|
||||
@mixin gridPosition($rowStart, $rowEnd, $columnStart, $columnEnd)
|
||||
grid-row-start: $rowStart
|
||||
grid-row-end: $rowEnd
|
||||
grid-column-start: $columnStart
|
||||
grid-column-end: $columnEnd
|
@ -0,0 +1,108 @@
|
||||
@import "vars"
|
||||
@import "mixins"
|
||||
|
||||
body
|
||||
font-family: Arial, serif
|
||||
|
||||
button
|
||||
border: 2px solid $cPrimary
|
||||
margin-top: 0.125em
|
||||
padding: 0.125em
|
||||
background-color: $cPrimary
|
||||
color: $cPrimarySurface
|
||||
font-weight: bold
|
||||
transition-duration: 0.25s
|
||||
|
||||
button:hover
|
||||
background-color: lighten($cPrimary, 10%)
|
||||
cursor: pointer
|
||||
|
||||
button:active
|
||||
background-color: darken($cPrimary, 5%)
|
||||
box-shadow: inset 0.25em 0.25em 0.1em rgba(0, 0, 0, 0.25)
|
||||
|
||||
.stylebar
|
||||
@include gridPosition(1, 2, 1, 4)
|
||||
display: grid
|
||||
grid-template: 100% /25% 50% 25%
|
||||
background-color: $cPrimary
|
||||
color: $cPrimarySurface
|
||||
|
||||
h1
|
||||
@include gridPosition(1, 2, 1, 2)
|
||||
text-align: center
|
||||
margin: auto
|
||||
|
||||
#content
|
||||
grid-template: 7.5% 92.5% / 25% 50% 25%
|
||||
display: grid
|
||||
width: 100%
|
||||
height: 100%
|
||||
|
||||
#friendscontainer
|
||||
@include gridPosition(2, 3, 1, 2)
|
||||
background-color: $cPrimaryBackground
|
||||
|
||||
#input-login
|
||||
margin-top: 1em
|
||||
@include gridPosition(2,3,2,3)
|
||||
grid-template: 7.5% 7.5% 7.5% 7.5% 72%/ 100%
|
||||
display: grid
|
||||
background-color: $cPrimaryBackground
|
||||
|
||||
input
|
||||
margin: 0.25em
|
||||
|
||||
.loginButton
|
||||
margin: 0.25em
|
||||
|
||||
#input-register
|
||||
margin-top: 1em
|
||||
@include gridPosition(2,3,2,3)
|
||||
grid-template: 7.5% 7.5% 7.5% 7.5% 7.5% 7.5% 58%/ 100%
|
||||
display: grid
|
||||
background-color: $cPrimaryBackground
|
||||
|
||||
input
|
||||
margin: 0.25em
|
||||
|
||||
.registerButton
|
||||
margin: 0.25em
|
||||
|
||||
#feedcontainer
|
||||
@include gridPosition(2, 3, 2, 3)
|
||||
background-color: $cSecondaryBackground
|
||||
.postinput
|
||||
margin: 0.5em
|
||||
input
|
||||
width: 100%
|
||||
border-radius: 0.25em
|
||||
border: 1px solid $cPrimary
|
||||
padding: 0.125em
|
||||
height: 2em
|
||||
button.submitbutton
|
||||
border-radius: 0.25em
|
||||
height: 2em
|
||||
|
||||
.feeditem
|
||||
background-color: $cPrimaryBackground
|
||||
min-height: 2em
|
||||
margin: 0.5em
|
||||
padding: 0.25em
|
||||
border-radius: 0.25em
|
||||
.itemhead
|
||||
align-items: flex-start
|
||||
|
||||
.title, .handle, .date
|
||||
margin: 0.125em
|
||||
.title
|
||||
font-weight: bold
|
||||
|
||||
.handle, .date
|
||||
color: $cInactiveText
|
||||
.handle a
|
||||
text-decoration: none
|
||||
color: $cInactiveText
|
||||
font-style: normal
|
||||
.handle a:hover
|
||||
text-decoration: underline
|
@ -0,0 +1,5 @@
|
||||
$cPrimaryBackground: #fff
|
||||
$cSecondaryBackground: #ddd
|
||||
$cInactiveText: #555
|
||||
$cPrimary: #0d6b14
|
||||
$cPrimarySurface: #fff
|
@ -0,0 +1,101 @@
|
||||
import {Router} from "express";
|
||||
import {Namespace, Server} from "socket.io";
|
||||
import dataaccess from "../lib/dataaccess";
|
||||
import {ChatMessage} from "../lib/dataaccess/ChatMessage";
|
||||
import {Chatroom} from "../lib/dataaccess/Chatroom";
|
||||
import {Post} from "../lib/dataaccess/Post";
|
||||
import {Request} from "../lib/dataaccess/Request";
|
||||
import globals from "../lib/globals";
|
||||
import {InternalEvents} from "../lib/InternalEvents";
|
||||
import Route from "../lib/Route";
|
||||
|
||||
/**
|
||||
* list of chatroom socket namespaces.
|
||||
*/
|
||||
const chatRooms: Namespace[] = [];
|
||||
|
||||
/**
|
||||
* Class for the home route.
|
||||
*/
|
||||
class HomeRoute extends Route {
|
||||
/**
|
||||
* Constructor, creates new router.
|
||||
*/
|
||||
constructor() {
|
||||
super();
|
||||
this.router = Router();
|
||||
}
|
||||
|
||||
/**
|
||||
* Asynchronous init for socket.io.
|
||||
* @param io - the io instance
|
||||
*/
|
||||
public async init(io: Server) {
|
||||
this.io = io;
|
||||
|
||||
io.on("connection", (socket) => {
|
||||
socket.on("postCreate", async (content) => {
|
||||
if (socket.handshake.session.userId) {
|
||||
const post = await dataaccess.createPost(content, socket.handshake.session.userId);
|
||||
io.emit("post", await post.resolvedData());
|
||||
} else {
|
||||
socket.emit("error", "Not logged in!");
|
||||
}
|
||||
});
|
||||
globals.internalEmitter.on(InternalEvents.REQUESTCREATE, (request: Request) => {
|
||||
if (request.receiver.id === socket.handshake.session.userId) {
|
||||
socket.emit("request", request.resolvedData());
|
||||
}
|
||||
});
|
||||
globals.internalEmitter.on(InternalEvents.GQLPOSTCREATE, async (post: Post) => {
|
||||
socket.emit("post", await post.resolvedData());
|
||||
});
|
||||
});
|
||||
|
||||
const chats = await dataaccess.getAllChats();
|
||||
for (const chat of chats) {
|
||||
chatRooms[chat.id] = this.getChatSocketNamespace(chat.id);
|
||||
}
|
||||
globals.internalEmitter.on(InternalEvents.CHATCREATE, (chat: Chatroom) => {
|
||||
chatRooms[chat.id] = this.getChatSocketNamespace(chat.id);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Destroys the instance by dereferencing the router and resolver.
|
||||
*/
|
||||
public async destroy(): Promise<void> {
|
||||
this.router = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the namespace socket for a chat socket.
|
||||
* @param chatId
|
||||
*/
|
||||
private getChatSocketNamespace(chatId: number) {
|
||||
if (chatRooms[chatId]) {
|
||||
return chatRooms[chatId];
|
||||
}
|
||||
const chatNs = this.io.of(`/chat/${chatId}`);
|
||||
chatNs.on("connection", (socket) => {
|
||||
socket.on("chatMessage", async (content) => {
|
||||
if (socket.handshake.session.userId) {
|
||||
const userId = socket.handshake.session.userId;
|
||||
const message = await dataaccess.sendChatMessage(userId, chatId, content);
|
||||
socket.broadcast.emit("chatMessage", message.resolvedContent());
|
||||
socket.emit("chatMessageSent", message.resolvedContent());
|
||||
} else {
|
||||
socket.emit("error", "Not logged in!");
|
||||
}
|
||||
});
|
||||
globals.internalEmitter.on(InternalEvents.GQLCHATMESSAGE, (message: ChatMessage) => {
|
||||
if (message.chat.id === chatId) {
|
||||
socket.emit("chatMessage", message.resolvedContent());
|
||||
}
|
||||
});
|
||||
});
|
||||
return chatNs;
|
||||
}
|
||||
}
|
||||
|
||||
export default HomeRoute;
|
@ -0,0 +1,34 @@
|
||||
/**
|
||||
* @author Trivernis
|
||||
* @remarks
|
||||
*
|
||||
* Taken from {@link https://github.com/Trivernis/whooshy}
|
||||
*/
|
||||
|
||||
import {Router} from "express";
|
||||
import {Server} from "socket.io";
|
||||
|
||||
import HomeRoute from "./home";
|
||||
|
||||
const homeRoute = new HomeRoute();
|
||||
|
||||
/**
|
||||
* Namespace to manage the routes of the server.
|
||||
* Allows easier assignments of graphql endpoints, socket.io connections and routers when
|
||||
* used with {@link Route}.
|
||||
*/
|
||||
namespace routes {
|
||||
export const router = Router();
|
||||
|
||||
router.use("/", homeRoute.router);
|
||||
|
||||
/**
|
||||
* Assigns the io listeners or namespaces to the routes
|
||||
* @param io
|
||||
*/
|
||||
export const ioListeners = async (io: Server) => {
|
||||
await homeRoute.init(io);
|
||||
};
|
||||
}
|
||||
|
||||
export default routes;
|
@ -0,0 +1,137 @@
|
||||
--create functions
|
||||
DO $$BEGIN
|
||||
|
||||
IF NOT EXISTS(SELECT 1 from pg_proc WHERE proname = 'function_exists') THEN
|
||||
CREATE FUNCTION function_exists(text) RETURNS boolean LANGUAGE plpgsql AS $BODY$
|
||||
BEGIN
|
||||
RETURN EXISTS(SELECT 1 from pg_proc WHERE proname = $1);
|
||||
END $BODY$;
|
||||
END IF;
|
||||
|
||||
IF NOT function_exists('type_exists') THEN
|
||||
CREATE FUNCTION type_exists(text) RETURNS boolean LANGUAGE plpgsql AS $BODY$
|
||||
BEGIN
|
||||
RETURN EXISTS (SELECT 1 FROM pg_type WHERE typname = $1);
|
||||
END $BODY$;
|
||||
END IF;
|
||||
|
||||
END$$;
|
||||
|
||||
--create types
|
||||
DO $$ BEGIN
|
||||
|
||||
IF NOT type_exists('votetype') THEN
|
||||
CREATE TYPE votetype AS enum ('DOWNVOTE', 'UPVOTE');
|
||||
END IF;
|
||||
|
||||
IF NOT type_exists('posttype') THEN
|
||||
CREATE TYPE posttype AS enum ('MISC', 'ACTION', 'IMAGE', 'TEXT');
|
||||
END IF;
|
||||
|
||||
IF NOT type_exists('requesttype') THEN
|
||||
CREATE TYPE requesttype AS enum ('FRIENDREQUEST');
|
||||
END IF;
|
||||
|
||||
END$$;
|
||||
|
||||
-- create functions relying on types
|
||||
|
||||
DO $$ BEGIN
|
||||
|
||||
IF NOT function_exists('cast_to_votetype') THEN
|
||||
CREATE FUNCTION cast_to_votetype(text) RETURNS votetype LANGUAGE plpgsql AS $BODY$
|
||||
BEGIN
|
||||
RETURN CASE WHEN $1::votetype IS NULL THEN 'UPVOTE' ELSE $1::votetype END;
|
||||
END $BODY$;
|
||||
END IF;
|
||||
|
||||
IF NOT function_exists('cast_to_posttype') THEN
|
||||
CREATE FUNCTION cast_to_posttype(text) RETURNS posttype LANGUAGE plpgsql AS $BODY$
|
||||
BEGIN
|
||||
RETURN CASE WHEN $1::posttype IS NULL THEN 'MISC' ELSE $1::posttype END;
|
||||
END $BODY$;
|
||||
END IF;
|
||||
|
||||
END$$;
|
||||
|
||||
-- create tables
|
||||
DO $$ BEGIN
|
||||
|
||||
CREATE TABLE IF NOT EXISTS "user_sessions" (
|
||||
"sid" varchar NOT NULL,
|
||||
"sess" json NOT NULL,
|
||||
"expire" timestamp(6) NOT NULL,
|
||||
PRIMARY KEY ("sid") NOT DEFERRABLE INITIALLY IMMEDIATE
|
||||
) WITH (OIDS=FALSE);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id SERIAL PRIMARY KEY,
|
||||
name varchar(128) NOT NULL,
|
||||
handle varchar(128) UNIQUE NOT NULL,
|
||||
password varchar(1024) NOT NULL,
|
||||
email varchar(128) UNIQUE NOT NULL,
|
||||
greenpoints INTEGER DEFAULT 0,
|
||||
joined_at TIMESTAMP DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS posts (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
upvotes INTEGER DEFAULT 0,
|
||||
downvotes INTEGER DEFAULT 0,
|
||||
created_at TIMESTAMP DEFAULT now(),
|
||||
content text,
|
||||
author SERIAL REFERENCES users (id) ON DELETE CASCADE,
|
||||
type posttype NOT NULL DEFAULT 'MISC'
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS votes (
|
||||
user_id SERIAL REFERENCES users (id) ON DELETE CASCADE,
|
||||
item_id BIGSERIAL REFERENCES posts (id) ON DELETE CASCADE,
|
||||
vote_type votetype DEFAULT 'DOWNVOTE',
|
||||
PRIMARY KEY (user_id, item_id)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS events (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
time TIMESTAMP,
|
||||
owner SERIAL REFERENCES users (id)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS event_members (
|
||||
event BIGSERIAL REFERENCES events (id),
|
||||
member SERIAL REFERENCES users (id),
|
||||
PRIMARY KEY (event, member)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chats (
|
||||
id BIGSERIAL PRIMARY KEY
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chat_messages (
|
||||
chat BIGSERIAL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
author SERIAL REFERENCES users (id) ON DELETE SET NULL,
|
||||
content VARCHAR(1024) NOT NULL,
|
||||
created_at TIMESTAMP DEFAULT now(),
|
||||
PRIMARY KEY (chat, author, created_at)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chat_members (
|
||||
chat BIGSERIAL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
member SERIAL REFERENCES users (id) ON DELETE CASCADE,
|
||||
PRIMARY KEY (chat, member)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS user_friends (
|
||||
user_id SERIAL REFERENCES users (id) ON DELETE CASCADE,
|
||||
friend_id SERIAL REFERENCES users (id) ON DELETE CASCADE,
|
||||
PRIMARY KEY (user_id, friend_id)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS requests (
|
||||
sender SERIAL REFERENCES users (id) ON DELETE CASCADE,
|
||||
receiver SERIAL REFERENCES users (id) ON DELETE CASCADE,
|
||||
type requesttype DEFAULT 'FRIENDREQUEST',
|
||||
PRIMARY KEY (sender, receiver, type)
|
||||
);
|
||||
|
||||
END $$;
|
@ -0,0 +1,19 @@
|
||||
DO $$ BEGIN
|
||||
|
||||
ALTER TABLE IF EXISTS votes
|
||||
ADD COLUMN IF NOT EXISTS vote_type votetype DEFAULT 'UPVOTE',
|
||||
ALTER COLUMN vote_type TYPE votetype USING cast_to_votetype(vote_type::text),
|
||||
ALTER COLUMN vote_type DROP DEFAULT,
|
||||
ALTER COLUMN vote_type SET DEFAULT 'UPVOTE';
|
||||
|
||||
ALTER TABLE IF EXISTS posts
|
||||
ALTER COLUMN type TYPE posttype USING cast_to_posttype(type::text),
|
||||
ALTER COLUMN type DROP DEFAULT,
|
||||
ALTER COLUMN type SET DEFAULT 'MISC',
|
||||
DROP COLUMN IF EXISTS upvotes,
|
||||
DROP COLUMN IF EXISTS downvotes;
|
||||
|
||||
ALTER TABLE requests
|
||||
ADD COLUMN IF NOT EXISTS type requesttype DEFAULT 'FRIENDREQUEST';
|
||||
|
||||
END $$;
|
@ -0,0 +1,31 @@
|
||||
{
|
||||
"extends": "tslint:recommended",
|
||||
"rulesDirectory": [],
|
||||
"rules": {
|
||||
"max-line-length": {
|
||||
"options": [120]
|
||||
},
|
||||
"new-parens": true,
|
||||
"no-arg": true,
|
||||
"no-bitwise": true,
|
||||
"no-conditional-assignment": true,
|
||||
"no-consecutive-blank-lines": false,
|
||||
"cyclomatic-complexity": true,
|
||||
"brace-style": "1tbs",
|
||||
"semicolon": true,
|
||||
"indent": [true, "spaces", 4],
|
||||
"no-shadowed-variable": true,
|
||||
"no-console": {
|
||||
"severity": "warning",
|
||||
"options": ["debug", "info", "log", "time", "timeEnd", "trace"]
|
||||
},
|
||||
"no-namespace": false,
|
||||
"no-internal-module": false,
|
||||
"max-classes-per-file": false
|
||||
},
|
||||
"jsRules": {
|
||||
"max-line-length": {
|
||||
"options": [120]
|
||||
}
|
||||
}
|
||||
}
|
Loading…
Reference in New Issue