Merge pull request #109 from boostcampwm-2021/develop

0.2.1

Author: hyunmindev

backend/package-lock.json

@@ -7,8 +7,9 @@
     "pm2": "pm2 restart node_modules/.bin/ts-node -- -r tsconfig-paths/register ./src/bin/www.ts"
   },
   "dependencies": {
-    "@types/passport-github": "^1.1.6",
+    "aws-sdk": "^2.348.0",
     "axios": "^0.24.0",
+    "cheerio": "^1.0.0-rc.10",
     "cookie-parser": "~1.4.4",
     "cors": "^2.8.5",
     "debug": "~2.6.9",
@@ -18,8 +19,10 @@
     "js-base64": "^3.7.2",
     "jsonwebtoken": "^8.5.1",
     "mongoose": "^6.0.12",
+    "mongoose-lean-virtuals": "^0.9.0",
     "morgan": "~1.9.1",
     "nanoid": "^3.1.30",
+    "nodemailer": "^6.7.1",
     "passport": "^0.5.0",
     "passport-github": "^1.1.0",
     "passport-google-oauth": "^2.0.0",
@@ -29,13 +32,17 @@
     "routing-controllers": "^0.9.0"
   },
   "devDependencies": {
+    "@types/cheerio": "^0.22.30",
     "@types/cookie-parser": "^1.4.2",
     "@types/cors": "^2.8.12",
     "@types/express": "^4.17.13",
     "@types/jsonwebtoken": "^8.5.5",
+    "@types/mongoose-lean-virtuals": "^0.5.2",
     "@types/morgan": "^1.9.3",
     "@types/node": "^16.11.6",
+    "@types/nodemailer": "^6.4.4",
     "@types/passport": "^1.0.7",
+    "@types/passport-github": "^1.1.6",
     "@types/passport-google-oauth": "^1.0.42",
     "@types/passport-jwt": "^3.0.6",
     "@typescript-eslint/eslint-plugin": "^5.2.0",

backend/package.json

@@ -1,6 +1,6 @@
-import { Application } from 'express';
 import * as passport from 'passport';
 import * as GitHubStrategy from 'passport-github';
+import { User } from 'src/models';
 
 import { UserService } from 'src/services';
 
@@ -19,10 +19,19 @@ export default function passportGithubLoader(): void {
   ) => {
     try {
       const { id, login: username } = profile._json;
-      const user = await UserService.findOrCreateUserForProvider({
-        authProvider: 'github',
-        authProviderID: id,
-      });
+      const userIsExist = await UserService.existGithubUser(username);
+      let user;
+      if (userIsExist) {
+        const temp = await UserService.updateGithubUserInfo(username, { githubUsername: username });
+        user = { userID: temp };
+      } else {
+        user = await UserService.findOrCreateUserForProvider({
+          authProvider: 'github',
+          authProviderID: id,
+          githubUsername: username,
+        });
+      }
+
       return cb(null, user);
     } catch (err) {
       return cb(err);

backend/src/loaders/passportGithubLoader.ts

@@ -0,0 +1,16 @@
+import { Schema, model, Types } from 'mongoose';
+
+import { BlogType } from 'src/types/modelType';
+import { Validate } from 'src/utils';
+
+const blogSchema = new Schema<BlogType>(
+  {
+    url: { type: String, required: true },
+    identity: { type: String, required: true },
+    type: { type: String, required: true, enum: ['tistory', 'velog'] },
+    userID: { type: Types.ObjectId, required: true, validate: Validate.userObjectID },
+  },
+  { versionKey: false, timestamps: false },
+);
+
+export default model<BlogType>('Blog', blogSchema);

backend/src/models/Blog.ts

@@ -0,0 +1,29 @@
+import { Schema, model, Types } from 'mongoose';
+
+import { CommentType } from 'src/types/modelType';
+import { Validate } from 'src/utils';
+
+const commentSchema = new Schema<CommentType>(
+  {
+    userID: { type: Types.ObjectId, required: true, ref: 'User', validate: Validate.userObjectID },
+    postID: { type: Types.ObjectId, required: true, ref: 'Post', validate: Validate.postObjectID },
+    content: { type: String, required: true },
+  },
+  { versionKey: false, timestamps: true },
+);
+
+commentSchema.virtual('user', {
+  ref: 'User',
+  localField: 'userID',
+  foreignField: '_id',
+  justOne: true,
+});
+
+commentSchema.virtual('post', {
+  ref: 'Post',
+  localField: 'postID',
+  foreignField: '_id',
+  justOne: true,
+});
+
+export default model<CommentType>('Comment', commentSchema);

backend/src/models/Comment.ts

@@ -0,0 +1,29 @@
+import { Schema, model, Types } from 'mongoose';
+import * as mongooseLeanVirtuals from 'mongoose-lean-virtuals';
+
+import { CommentLikeType } from 'src/types/modelType';
+import { Validate } from 'src/utils';
+
+const commentLikeSchema = new Schema<CommentLikeType>(
+  {
+    userID: { type: Types.ObjectId, required: true, ref: 'User', validate: Validate.userObjectID },
+    commentID: {
+      type: Types.ObjectId,
+      required: true,
+      ref: 'Comment',
+      validate: Validate.commentObjectID,
+    },
+  },
+  { versionKey: false, timestamps: { createdAt: true, updatedAt: false } },
+);
+
+commentLikeSchema.virtual('user', {
+  ref: 'User',
+  localField: 'userID',
+  foreignField: '_id',
+  justOne: true,
+});
+
+commentLikeSchema.plugin(mongooseLeanVirtuals);
+
+export default model<CommentLikeType>('CommentLike', commentLikeSchema);

backend/src/models/CommentLike.ts

@@ -0,0 +1,15 @@
+import { Schema, model, Types } from 'mongoose';
+
+import { DashboardHistoryType } from 'src/types/modelType';
+import { Validate } from 'src/utils';
+
+const dashboardHistorySchema = new Schema<DashboardHistoryType>(
+  {
+    userID: { type: Types.ObjectId, required: true, ref: 'User', validate: Validate.userObjectID },
+    content: { type: String },
+    date: { type: Date },
+  },
+  { versionKey: false },
+);
+
+export default model<DashboardHistoryType>('DashboardHistory', dashboardHistorySchema);

backend/src/models/DashboardHistory.ts

@@ -0,0 +1,15 @@
+import { Schema, model, Types } from 'mongoose';
+
+import { DashboardRepositoryType } from 'src/types/modelType';
+import { Validate } from 'src/utils';
+
+const dashboardRepositorySchema = new Schema<DashboardRepositoryType>(
+  {
+    userID: { type: Types.ObjectId, required: true, ref: 'User', validate: Validate.userObjectID },
+    title: { type: String },
+    content: { type: String },
+  },
+  { versionKey: false, timestamps: true },
+);
+
+export default model<DashboardRepositoryType>('DashboardRepository', dashboardRepositorySchema);

backend/src/models/DashboardRepository.ts

@@ -0,0 +1,15 @@
+import { Schema, model, Types } from 'mongoose';
+
+import { EchoMessageType } from 'src/types';
+import { Validate } from 'src/utils';
+
+const echoMessageSchema = new Schema<EchoMessageType>(
+  {
+    roomID: { type: Types.ObjectId, ref: 'User', validate: Validate.echoRoomObjectID },
+    content: { type: String, required: true },
+    isRead: { type: Boolean, default: false, required: true },
+  },
+  { timestamps: { createdAt: true, updatedAt: false } },
+);
+
+export default model<EchoMessageType>('EchoMessage', echoMessageSchema);

backend/src/models/EchoMessage.ts

@@ -1,23 +1,13 @@
 import { Schema, model, Types } from 'mongoose';
 
-import { EchoRoomType, MessageType } from 'src/types';
+import { EchoRoomType } from 'src/types';
 import { Validate } from 'src/utils';
 
-const messageSchema = new Schema<MessageType>(
-  {
-    userID: { type: Types.ObjectId, ref: 'User', validate: Validate.userObjectID },
-    content: { type: String, required: true },
-    isRead: { type: Boolean, default: false, required: true },
-  },
-  { timestamps: true },
-);
-
 const echoRoomSchema = new Schema<EchoRoomType>(
   {
     users: [{ type: Types.ObjectId, ref: 'User', required: true, validate: Validate.userObjectID }],
-    messages: [messageSchema],
   },
-  { versionKey: false, timestamps: { createdAt: false, updatedAt: true } },
+  { versionKey: false },
 );
 
 export default model<EchoRoomType>('EchoRoom', echoRoomSchema);

backend/src/models/EchoRoom.ts

@@ -0,0 +1,41 @@
+import { Schema, model, Types } from 'mongoose';
+import * as mongooseLeanVirtuals from 'mongoose-lean-virtuals';
+
+import { FollowType } from 'src/types/modelType';
+import { Validate } from 'src/utils';
+
+const followSchema = new Schema<FollowType>(
+  {
+    followID: {
+      type: Types.ObjectId,
+      required: true,
+      ref: 'User',
+      validate: Validate.userObjectID,
+    },
+    followerID: {
+      type: Types.ObjectId,
+      required: true,
+      ref: 'User',
+      validate: Validate.userObjectID,
+    },
+  },
+  { versionKey: false, timestamps: { createdAt: true, updatedAt: false } },
+);
+
+followSchema.virtual('follow', {
+  ref: 'User',
+  localField: 'followID',
+  foreignField: '_id',
+  justOne: true,
+});
+
+followSchema.virtual('follower', {
+  ref: 'User',
+  localField: 'followerID',
+  foreignField: '_id',
+  justOne: true,
+});
+
+followSchema.plugin(mongooseLeanVirtuals);
+
+export default model<FollowType>('Follow', followSchema);

backend/src/models/Follow.ts

@@ -0,0 +1,19 @@
+import { Schema, model, Types } from 'mongoose';
+
+import { ImageType } from 'src/types/modelType';
+import { Validate } from 'src/utils';
+
+const imageSchema = new Schema<ImageType>(
+  {
+    url: { type: String, required: true },
+    targetID: {
+      type: Types.ObjectId,
+      required: true,
+      ref: 'Post',
+      validate: Validate.postObjectID,
+    },
+  },
+  { versionKey: false },
+);
+
+export default model<ImageType>('Image', imageSchema);

backend/src/models/Image.ts

@@ -1,12 +1,13 @@
 import { model, Schema, Types } from 'mongoose';
+
 import { NotifyType } from 'src/types';
 import { Validate } from 'src/utils';
 
 const notifySchema = new Schema<NotifyType>(
   {
     type: {
       type: String,
-      enum: ['postLike', 'postComment', 'commentLike', 'follow', 'follower'],
+      enum: ['postComment', 'postLike', 'commentLike', 'follow'],
       required: true,
     },
     userID: {
@@ -16,9 +17,16 @@ const notifySchema = new Schema<NotifyType>(
       validate: Validate.userObjectID,
       index: true,
     },
+    senderID: {
+      type: Types.ObjectId,
+      ref: 'User',
+      required: true,
+      validate: Validate.userObjectID,
+      index: true,
+    },
     postID: { type: Types.ObjectId, ref: 'Post', validate: Validate.postObjectID },
   },
-  { timestamps: { createdAt: true, updatedAt: false } },
+  { versionKey: false, timestamps: { createdAt: true, updatedAt: false } },
 );
 
 export default model<NotifyType>('Notify', notifySchema);

backend/src/models/Language.ts

@@ -1,42 +1,45 @@
 import { Schema, model, Types } from 'mongoose';
+import * as mongooseLeanVirtuals from 'mongoose-lean-virtuals';
 
-import { CommentType, PostType, LikeType } from 'src/types/modelType';
+import { PostType } from 'src/types/modelType';
 import { Validate } from 'src/utils';
 
-const likeSchema = new Schema<LikeType>(
-  {
-    userID: { type: Types.ObjectId, ref: 'User', required: true, validate: Validate.userObjectID },
-  },
-  { _id: false, timestamps: { createdAt: true, updatedAt: false } },
-);
-
-const commentSchema = new Schema<CommentType>(
-  {
-    userID: { type: Types.ObjectId, ref: 'User', required: true, validate: Validate.userObjectID },
-    content: { type: String, required: true },
-    likes: { type: [likeSchema], default: [] },
-  },
-  { _id: true, timestamps: true },
-);
-
 const postSchema = new Schema<PostType>(
   {
     title: { type: String, trim: true },
     content: { type: String, required: true, trim: true },
     userID: { type: Types.ObjectId, required: true, ref: 'User', validate: Validate.userObjectID },
-    githubUsername: { type: String, trim: true },
-    images: {
-      type: [{ type: String, validate: [Validate.url, 'URL 형식이 잘못되었습니다.'] }],
-      default: [],
-    },
-    comments: { type: [commentSchema], default: [] },
-    likes: { type: [likeSchema], default: [] },
     tags: {
       type: [{ type: Types.ObjectId, ref: 'Tag', required: true, validate: Validate.tagObjectID }],
       default: [],
     },
+    type: {
+      type: String,
+      enum: ['normal', 'github', 'blog', 'algorithm'],
+      required: true,
+      default: 'normal',
+    },
+    link: { type: String, trim: true },
+    externalContent: { type: String, trim: true },
+    external: {
+      type: { type: String, enum: ['github', 'tistory', 'velog'] },
+      identity: { type: String, trim: true },
+      target: { type: String, trim: true },
+    },
+    blog: { type: String, enum: ['tistory', 'velog'] },
+    blogIdentity: String,
+    blogPostID: String,
   },
   { versionKey: false, timestamps: true },
 );
 
+postSchema.virtual('user', {
+  ref: 'User',
+  localField: 'userID',
+  foreignField: '_id',
+  justOne: true,
+});
+
+postSchema.plugin(mongooseLeanVirtuals);
+
 export default model<PostType>('Post', postSchema);