diff --git a/src/models/ApplicantSchema.ts b/src/models/ApplicantSchema.ts
deleted file mode 100644
index 98395cfd521d8183ffb7d24b689d6945f7fb9eda..0000000000000000000000000000000000000000
--- a/src/models/ApplicantSchema.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { Document, Schema, model } from "mongoose";
-import { IProfile } from "./ProfileSchema";
-
-export enum CardStatus {
-  Requested,
-  Printed,
-  Received,
-}
-
-export interface IApplicant extends Document {
-  cardStatus: CardStatus;
-  profile: {
-    name: string;
-    id: IProfile["_id"];
-  };
-}
-
-const ApplicationSchema = new Schema({
-  cardStatus: { type: String, required: true },
-  profile: {
-    id: { type: Schema.Types.ObjectId, required: true },
-    name: { type: String, required: true },
-  },
-});
-
-export default model<IApplicant>("Applicant", ApplicationSchema);
diff --git a/src/models/ApplicationPeriodSchema.ts b/src/models/ApplicationPeriodSchema.ts
deleted file mode 100644
index ce974cbabdd47d5a10436312ffa5e79086268c53..0000000000000000000000000000000000000000
--- a/src/models/ApplicationPeriodSchema.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { Document, Schema, model } from "mongoose";
-import ApplicantSchema, { IApplicant } from "./ApplicantSchema";
-
-export interface IApplicationPeriod extends Document {
-  startAt: Date;
-  endAt: Date;
-  deadline: Date;
-  name: string;
-  applicants: IApplicant[];
-}
-
-const ApplicationPeriodSchema = new Schema({
-  startedAt: { type: Date, required: true },
-  endAt: { type: Date, required: true },
-  deadline: { type: Date, required: true },
-  name: { type: String, required: true },
-  applicants: [ApplicantSchema],
-});
-
-export default model<IApplicationPeriod>(
-  "Application period",
-  ApplicationPeriodSchema
-);
diff --git a/src/models/CardImageSchema.ts b/src/models/CardImageSchema.ts
deleted file mode 100644
index 17bfdb35a20d76ee72e7e4beea1b0d6d68b65071..0000000000000000000000000000000000000000
--- a/src/models/CardImageSchema.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { Document, Schema, model } from "mongoose";
-
-export interface ICardImage extends Document {
-  imageId: String;
-}
-
-const CardImageSchema = new Schema({
-  imageId: { type: Schema.Types.ObjectId, ref: "File", required: true },
-});
-
-export default model<ICardImage>("CardImage", CardImageSchema);
diff --git a/src/models/CardSchema.ts b/src/models/CardSchema.ts
deleted file mode 100644
index aaec08da2909f654b739b7a4909a3d873f7abe1f..0000000000000000000000000000000000000000
--- a/src/models/CardSchema.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import CounterSchema, { ICounter } from "./CounterSchema";
-import { Document, Schema, model } from "mongoose";
-
-import ProfileSchema from "./ProfileSchema";
-
-export interface ICard extends Document {
-  userId: string;
-  fullName: string;
-  roomNumber: Number;
-  cardId: Number;
-  createDate: Date;
-  expirationDate: Date;
-  isTaken: boolean;
-}
-
-const CardSchema = new Schema({
-  userId: { type: Schema.Types.ObjectId, ref: "User" },
-  fullName: { type: String, required: true },
-  roomNumber: { type: Number, required: true },
-  cardId: { type: Number },
-  createDate: { type: Date, required: true, default: new Date() },
-  expirationDate: { type: Date, required: true },
-  isTaken: { type: Boolean, required: true, default: false },
-});
-
-CardSchema.pre("save", function (this: ICard, next) {
-  var doc = this;
-  CounterSchema.findByIdAndUpdate(
-    { _id: "cardId" },
-    { $inc: { seq: 1 } },
-    { upsert: true, new: true },
-    function (error, counter: ICounter | null) {
-      if (error) return next(error);
-      doc.cardId = counter!.seq;
-      next();
-    }
-  );
-});
-
-export default model<ICard>("Card", CardSchema);
diff --git a/src/models/CounterSchema.ts b/src/models/CounterSchema.ts
index 40a889642ab571cd7e74c6c4535c2ce1409bfcc7..cadcb72900e4b9d1485697c8636411552981f56d 100644
--- a/src/models/CounterSchema.ts
+++ b/src/models/CounterSchema.ts
@@ -10,4 +10,18 @@ const CounterSchema = new Schema({
   seq: { type: Number, default: 0 },
 });
 
+// CardSchema.pre("save", function (this: ICard, next) {
+//   var doc = this;
+//   CounterSchema.findByIdAndUpdate(
+//     { _id: "cardId" },
+//     { $inc: { seq: 1 } },
+//     { upsert: true, new: true },
+//     function (error, counter: ICounter | null) {
+//       if (error) return next(error);
+//       doc.cardId = counter!.seq;
+//       next();
+//     }
+//   );
+// });
+
 export default model<ICounter>("Counter", CounterSchema);
diff --git a/src/models/FileSchema.ts b/src/models/FileSchema.ts
index fa6679432e7e646cfbd5a2eeab62514ef56ff892..268514c62f9c86758e653e11a99cf5573d7562d3 100644
--- a/src/models/FileSchema.ts
+++ b/src/models/FileSchema.ts
@@ -3,7 +3,6 @@ import { Document, Schema, model } from "mongoose";
 export interface IFile extends Document {
   path: string;
   originalName: string;
-  encoding: string;
   mimeType: string;
   uploadDate: Date;
 }
diff --git a/src/models/NewsSchema.ts b/src/models/NewsSchema.ts
index e82064d5e6817af472547b8b25a518b3bf285f5f..72d32c23ea500a05c3402f1dc2426a2b7c9a6419 100644
--- a/src/models/NewsSchema.ts
+++ b/src/models/NewsSchema.ts
@@ -4,12 +4,16 @@ export interface INews extends Document {
   title: string;
   text: string;
   publishedAt: Date;
+  publishedBy: string;
+  updatedBy?: string;
 }
 
 const NewsSchema = new Schema({
   title: { type: String, required: true },
   text: { type: String, required: true },
   publishedAt: { type: Date, required: true },
+  publishedBy: { type: Schema.Types.ObjectId, ref: "Profile", required: true },
+  updatedBy: { type: Schema.Types.ObjectId, ref: "Profile", required: false },
 });
 
 export default model<INews>("News", NewsSchema);
diff --git a/src/models/NotificationSchema.ts b/src/models/NotificationSchema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3914dc7301c7fd583373b1ee952dc38c8ce78d95
--- /dev/null
+++ b/src/models/NotificationSchema.ts
@@ -0,0 +1,13 @@
+import { Document, Schema, model } from "mongoose";
+
+export interface INotification extends Document {
+  text: string;
+  redirect?: string;
+}
+
+const NotificationSchema = new Schema({
+  text: { type: String, required: true },
+  redirect: { type: String, required: false },
+});
+
+export default model<INotification>("Notification", NotificationSchema);
diff --git a/src/models/ProfileSchema.ts b/src/models/ProfileSchema.ts
index e01b02d010952d14475116aa0d02ef42bdb72a80..c0546b7967ea5432f57cef283c263c9706682acd 100644
--- a/src/models/ProfileSchema.ts
+++ b/src/models/ProfileSchema.ts
@@ -4,37 +4,45 @@ import { IWarning, WarningSchema } from "./WarningSchema";
 import { Admin } from "mongodb";
 
 export enum Role {
-  Admin,
-  Staff,
-  User,
+  Admin = "ADMIN",
+  Staff = "STAFF",
+  User = "USER",
 }
 
 export interface IProfile extends Document {
-  external_id: string;
-  studentCardNumber: string;
-  roomNumber: Number;
-  pictureId: string;
+  externalId: string;
+  studentCardNumber?: string;
+  roomNumber?: Number;
+  picture?: string;
+  acceptedPicture?: string;
   role: Role;
   email: string;
   name: string;
-  warningIds: string[] | [];
+  warnings: string[] | [];
+  notifications: string[] | [];
 }
 
 const ProfileSchema = new Schema({
-  external_id: { type: String, required: true, unique: true, dropDups: true },
+  externalId: { type: String, required: true, unique: true, dropDups: true },
   studentCardNumber: { type: String, required: false },
-  roomNumber: { type: Number },
-  pictureId: { type: Schema.Types.ObjectId, ref: "File", required: false },
+  roomNumber: { type: Number, required: false },
+  picture: { type: Schema.Types.ObjectId, ref: "File", required: false },
+  acceptedPicture: {
+    type: Schema.Types.ObjectId,
+    ref: "File",
+    required: false,
+  },
   role: {
     type: String,
-    enum: Object.keys(Role).map((k) => Role[k as any]),
+    enum: Object.keys(Role).map((k) => Role[k as keyof typeof Role]),
     required: true,
     default: Role.User,
   },
   email: { type: String, required: true },
   name: { type: String, required: true },
-  warningIds: [
-    { type: Schema.Types.ObjectId, ref: "Warning", required: false },
+  warnings: [{ type: Schema.Types.ObjectId, ref: "Warning", required: false }],
+  notifications: [
+    { type: Schema.Types.ObjectId, ref: "Notification", required: false },
   ],
 });
 
diff --git a/src/models/TermSchema.ts b/src/models/TermSchema.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5a1de32d37b9afd4d153f2425944b0c903138c68
--- /dev/null
+++ b/src/models/TermSchema.ts
@@ -0,0 +1,42 @@
+import { Document, Schema, model } from "mongoose";
+
+export enum MemberState {
+  Accepted = "ACCEPTED",
+  Applied = "APPLIED",
+  Rejected = "REJECTED",
+}
+
+export interface ITerm extends Document {
+  backgroundFile?: string;
+  name: string;
+  startDate: Date;
+  endDate: Date;
+  members: {
+    user: string;
+    state: MemberState;
+    cardNumber: number;
+    cardReceiveDate?: Date;
+  }[];
+}
+
+const TermSchema = new Schema({
+  backgroundFile: { type: Schema.Types.ObjectId, ref: "File", required: false },
+  name: { type: String, required: true },
+  startDate: { type: Date, required: true },
+  endDate: { type: Date, required: true },
+  members: [
+    {
+      required: false,
+      type: {
+        user: { type: Schema.Types.ObjectId, ref: "Profile", required: true },
+        state: Object.keys(MemberState).map(
+          (k) => MemberState[k as keyof typeof MemberState]
+        ),
+        cardNumber: { type: Number, required: true },
+        cardReceiveDate: { type: Date, required: false },
+      },
+    },
+  ],
+});
+
+export default model<ITerm>("Term", TermSchema);
diff --git a/src/models/WarningSchema.ts b/src/models/WarningSchema.ts
index 61dfef1c0a6ec1b8a562afd0e33550c8e852edbd..d58b12661972ea48727f965260a8bc28d45f8405 100644
--- a/src/models/WarningSchema.ts
+++ b/src/models/WarningSchema.ts
@@ -4,8 +4,8 @@ export interface IWarning extends Document {
   receiver: string;
   text: string;
   date: Date;
-  given_by: {
-    _id: string;
+  givenBy: {
+    id: string;
     name: string;
   };
 }
@@ -14,10 +14,10 @@ export const WarningSchema = new Schema({
   receiver: { type: Schema.Types.ObjectId, ref: "Profile", required: true },
   text: { type: String, required: true },
   date: { type: Date, required: true },
-  given_by: {
+  givenBy: {
     required: true,
     type: {
-      _id: { type: Schema.Types.ObjectId, ref: "Profile", required: true },
+      id: { type: Schema.Types.ObjectId, ref: "Profile", required: true },
       name: { String, required: true },
     },
   },
diff --git a/src/models/user.interface.ts b/src/models/user.interface.ts
index 1ec9320854428325a3fde3455b3891aa152ed57b..d12e54c3889f1d2b08ea529b897871e757224a8b 100644
--- a/src/models/user.interface.ts
+++ b/src/models/user.interface.ts
@@ -4,6 +4,6 @@ export interface User {
   email: string;
   name: string;
   id?: string;
-  external_id: string;
+  externalId: string;
   token: Token;
 }