Base Interface

interface Base {
    createdAt: Date;
    updatedAt: Date;
}

Enumerate

enum EChatRoomSocketEvent {
    // chatroom settings
    'CREATECHATROOM' = 'createchatroom',
    'UPDATECHATROOM' = 'updatechatroom',
    'DELETECHATROOM' = 'deletechatroom',
    // participate
    'UPDATEPARTICIPATE' = 'updateparticipate',
    'DELETEPARTICIPATE' = 'deleteparticipate',
    // message
    'NEWCHATMESSAGE' = 'newchatmessage',
    'UPDATESENDSTATUSMSG' = 'updatesendstatusmsg',
    'UPDATEREADSTATUSMSG' = 'updatereadstatusmsg',
}

enum EChatRoomType {
    'PUBLIC' = 'public',
    'PRIVATE' = 'private',
    'GROUP' = 'group',
}

enum EChatSendStatus {
    'FAIL' = 'fail',
    'SENDING' = 'sending',
    'FINISH' = 'finish',
}

enum EChatStatus {
    'READ' = 'read',
    'UNREAD' = 'unread',
}

enum EUserRole {
    'TRIAL' = 'trial',
    'USER' = 'user',
    'VIP1' = 'vip1',
    'VIP2' = 'vip2',
    'ADMIN' = 'admin',
}

enum EUserGender {
    'MALE' = 'male',
    'FEMALE' = 'female',
}

ChatRoom Interface

interface ChatRoom extends Base {
    id: string;
    name: string;
    type: EChatRoomType;
    chatParticipate: ChatParticipate;
    version: number;
}

chatParticipate Interface

interface ChatParticipate extends Base {
    id: string;
    chatRoom: ChatRoom;
    chats: Chat[];
    users: User[];
    version: number;
}

Chat Interface

interface Chat extends Base {
    id: string;
    message: string;
    sendStatus: EChatSendStatus;
    readStatus: EChatStatus;
    chatParticipate: ChatParticipate;
    version: number;
}

User Interface

interface User extends Base {
    id: string;
    role: EUserRole;
    expiredDate: Date;
    diamondCoin: number; // default 0
    goldCoin: number; // default 10
    username: string;
    email: string;
    status: boolean; // default true
    gender?: EUserGender
    age?: number;
    desc?: string;
    profileImage?: string;
    chatParticipates: ChatParticipates[];
    followers: User[];
    followings: User[];
    blockLists: User[];
    followerCount: number;
    followingCount: number;
    version: number;
}

enum EChatRoomType {
  'PUBLIC' = 'public',
  'PRIVATE' = 'private',
  'GROUP' = 'group',
}

interface AuthHeader {
    authorization: string;
}

interface CreateChatrooomDto {
    name: string;
    type: EChatRoomType; // default private
    welcomeMessage: string;
    requestUserId: string;
    responseUserId: string;
}

type Request = CreateChatrooomDto & AuthHeader;

type Response<Chatroom>;

interface AuthHeader {
    authorization: string;
}

interface CreatChatDto {
    message: string;
    chatParitcipateId: string;
    requestUserId: string;
    responseUserId: string;
}

type Request = CreatChatDto & AuthHeader;

type Response<Chat>;

interface AuthHeader {
    authorization: string;
}

interface ChatBasicDto {
    id: string;
}

type Request = ChatBasicDto & AuthHeader;

type Response<ChatRoom>;

interface AuthHeader {
    authorization: string;
}

interface IPage {
    take?: number;
    skip?: number;
}

interface ISearch extends IPage {
    keyword?: string;
    sort?: TSort;
    [futureKey: string]: any;
}

type Request = ISearch & AuthHeader;

interface PagingResponse {
    chatrooms: ChatRoom[];
    take: number;
    skip: number;
    count: number;
}

type Response<PagingResponse>;

interface SocketEventResponse {
    type: EChatRoomSocketEvent.UPDATEREADSTATUSMSG;
    data: ChatRoom;
}

type Response<SocketEventResponse>;

interface SocketEventResponse {
    type: EChatRoomSocketEvent.UPDATESENDSTATUSMSG;
    data: ChatRoom;
}

type Response<SocketEventResponse>;

interface SocketEventResponse {
    type: EChatRoomSocketEvent.NEWCHATMESSAGE;
    data: Chat;
}

type Response<SocketEventResponse>;

interface SocketEventResponse {
    type: EChatRoomSocketEvent.CREATECHATROOM;
    data: ChatRoom;
}

type Response<SocketEventResponse>;

interface SocketEventData {
    readStatus: EChatStatus,
    participateId: string;
    requestUserId: string;
    chatId: string;
}

interface SocketEvent {
    type: "updatereadstatus",
    data: SocketEventData
}

type Request = SocketEvent;

interface SocketEventData {
    sendStatus: EChatSendStatus,
    participateId: string;
    requestUserId: string;
    chatId: string;
}

interface SocketEvent {
    type: "updatesendstatus",
    data: SocketEventData
}

type Request = SocketEvent;

interface AuthHeader {
    authorization: string;
}

interface UpdateChatReadStatusDto {
    requestUserId: string;
    readStatus: EChatStatus;
}

type Request = UpdateChatReadStatusDto & AuthHeader;

type Response<Chat>;

interface AuthHeader {
    authorization: string;
}

interface UpdateChatSendStatusDto {
    requestUserId: string;
    sendStatus: EChatSendStatus;
}

type Request = UpdateChatSendStatusDto & AuthHeader;

type Response<Chat>;

Base Interface

interface Base {
    createdAt: Date;
    updatedAt: Date;
}

Enumerate

enum ELocationType {
    'COUNTRY' = 'country',
    'CITY' = 'city',
    'SCENE' = 'scene',
    'PORT' = 'port',
    'TURN' = 'turn',
}

enum EUserRole {
    'TRIAL' = 'trial',
    'USER' = 'user',
    'VIP1' = 'vip1',
    'VIP2' = 'vip2',
    'ADMIN' = 'admin',
}

enum EUserGender {
    'MALE' = 'male',
    'FEMALE' = 'female',
}

Geo Interface

type Position = number[];
type GeoJsonTypes = | 
    "Point" | 
    "MultiPoint" | 
    "LineString" |
    "MultiLineString" | 
    "Polygon" | 
    "MultiPolygon" |
    "GeometryCollection";
type BBox = [number, number, number, number] | [number, number, number, number, number, number];

export type GeometryObject = Geometry;

interface GeoJsonObject {
    type: GeoJsonTypes;
    bbox?: BBox;
}

interface MultiLineString extends GeoJsonObject {
    type: "MultiLineString";
    coordinates: Position[][];
}

interface LineString extends GeoJsonObject {
    type: "LineString";
    coordinates: Position[];
}

interface Point extends GeoJsonObject {
    type: "Point";
    coordinates: Position;
}

Location Interface

interface Location extends Base {
    id: string;
    point: Point;
    pointSrid: Point;
    lat: number;
    lon: number;
    type: ELocationType;
    locationName: string;
    country?: Country;
    startTrips?: Trip[];
    endTrips?: Trip[];
    version: number;
}

Country Interface

interface Country extends Base {
    id: string;
    name: string;
    code: string;
}

Turn Interface

interface Turn extends Base {
    id: string;
    name: string;
    geom: LineString;
    srid: LineString;
    length?: number;
    fromnode?: number;
    tonode?: number;
    version: number;
}

User Interface

interface User extends Base {
    id: string;
    role: EUserRole;
    expiredDate: Date;
    diamondCoin: number; // default 0
    goldCoin: number; // default 10
    username: string;
    email: string;
    status: boolean; // default true
    gender?: EUserGender
    age?: number;
    desc?: string;
    profileImage?: string;
    version: number;
}

interface AuthHeader {
    authorization: string;
}

interface GetLocationById {
  id: string;
}

type Request = GetLocationById & AuthHeader;

type Response<Location>;

type HealthIndicatorStatus = 'up' | 'down';
type HealthCheckStatus = 'error' | 'ok' | 'shutting_down';
type HealthIndicatorResult = {
    /**
     * The key of the health indicator which should be uniqe
     */
    [key: string]: {
        /**
         * The status if the given health indicator was successful or not
         */
        status: HealthIndicatorStatus;
        /**
         * Optional settings of the health indicator result
         */
        [optionalKeys: string]: any;
    };
};

interface HealthCheckResult {
    /**
     * The overall status of the Health Check
     */
    status: HealthCheckStatus;
    /**
     * The info object contains information of each health indicator
     * which is of status "up"
     */
    info?: HealthIndicatorResult;
    /**
     * The error object contains information of each health indicator
     * which is of status "down"
     */
    error?: HealthIndicatorResult;
    /**
     * The details object contains information of every health indicator.
     */
    details: HealthIndicatorResult;
}

type Response<HealthCheckResult>;

enum ELocationCoordQueryMethod {
  'SPECIFIC' = 'specific',
  'RANGE' = 'range',
}

interface AuthHeader {
    authorization: string;
}

interface IPage {
  take?: number;
  skip?: number;
}

interface ISearch extends IPage {
  lat: number;
  lon: number;
  method: ELocationCoordQueryMethod;
  range?: number;
}

type Request = ISearch & AuthHeader;

interface PagingResponse {
    locations: Location[];
    take: number;
    skip: number;
    count: number;
}

type Response<PagingResponse>;

interface AuthHeader {
    authorization: string;
}

interface IPage {
  take?: number;
  skip?: number;
}

interface ISearch extends IPage {
  keyword?: string;
  sort?: TSort;
  locationName?: string;
  countryName?: string;
  [futureKey: string]: any;
}

type Request = ISearch & AuthHeader;

interface PagingResponse {
    locations: Location[];
    take: number;
    skip: number;
    count: number;
}
type Response<PagingResponse>;

Base Interface

interface Base {
    createdAt: Date;
    updatedAt: Date;
}

Enumerate

enum ETripView {
    'PUBLIC' = 'public',
    'FRIEND' = 'friend',
    'SELF' = 'self',
}

enum ELocationType {
    'COUNTRY' = 'country',
    'CITY' = 'city',
    'SCENE' = 'scene',
    'PORT' = 'port',
    'TURN' = 'turn',
}

enum EUserRole {
    'TRIAL' = 'trial',
    'USER' = 'user',
    'VIP1' = 'vip1',
    'VIP2' = 'vip2',
    'ADMIN' = 'admin',
}

enum EUserGender {
    'MALE' = 'male',
    'FEMALE' = 'female',
}

Post Interface

interface Post extends Base {
    id: string;
    content: string;
    images: string;
    publicStatus: ETripView;
    publisher: User;
    likeUsers: User[];
    trip: Trip;
    version: number;
}

Geo Interface

type Position = number[];
type GeoJsonTypes = | 
    "Point" | 
    "MultiPoint" | 
    "LineString" |
    "MultiLineString" | 
    "Polygon" | 
    "MultiPolygon" |
    "GeometryCollection";
type BBox = [number, number, number, number] | [number, number, number, number, number, number];

export type GeometryObject = Geometry;

interface GeoJsonObject {
    type: GeoJsonTypes;
    bbox?: BBox;
}

interface MultiLineString extends GeoJsonObject {
    type: "MultiLineString";
    coordinates: Position[][];
}

interface Point extends GeoJsonObject {
    type: "Point";
    coordinates: Position;
}

Trip Interface

interface Trip extends Base {
    id: string;
    startDate: Date;
    endDate: Date;
    publicStatus: ETripView;
    companyName?: string;
    shipNumber?: string;
    geom?: MultiLineString;
    publisher: User;
    viewers: User[];
    startPoint: Location;
    endPoint: Location;
    version: number;
}

Location Interface

interface Location extends Base {
    id: string;
    point: Point;
    pointSrid: Point;
    lat: number;
    lon: number;
    type: ELocationType;
    locationName: string;
    country?: Country;
    startTrips?: Trip[];
    endTrips?: Trip[];
    version: number;
}

Country Interface

interface Country extends Base {
    id: string;
    name: string;
    code: string;
}

User Interface

interface User extends Base {
    id: string;
    role: EUserRole;
    expiredDate: Date;
    diamondCoin: number; // default 0
    goldCoin: number; // default 10
    username: string;
    email: string;
    status: boolean; // default true
    gender?: EUserGender
    age?: number;
    desc?: string;
    profileImage?: string;
    trips: Trip[];
    views: Trip[];
    posts: Post[];
    likePosts: Post[];
    followers: User[];
    followings: User[];
    blockLists: User[];
    followerCount: number;
    followingCount: number;
    version: number;
}

enum ETripView {
    'PUBLIC' = 'public',
    'FRIEND' = 'friend',
    'SELF' = 'self',
}

interface AuthHeader {
    authorization: string;
}

interface BufferedFile {
    fieldname: string;
    originalname: string;
    encoding: string;
    mimetype: AppMimeType;
    size: number;
    buffer: Buffer | string;
}

interface CreatePostDto {
    content: string;
    publicStatus: ETripView;
    tripId: string;
    publisherId: string;
    files: ITrip.BufferedFile[];
}

type Request = CreatePostDto & AuthHeader;

type Response<Post>;

interface AuthHeader {
    authorization: string;
}

interface PostBasicDto {
    id: string;
}

type Request = PostBasicDto & AuthHeader;

type Response<Post>;

interface AuthHeader {
    authorization: string;
}

interface IPage {
    take?: number;
    skip?: number;
}

interface ISearch extends IPage {
    keyword?: string;
    sort?: TSort;
    [futureKey: string]: any;
}

type Request = ISearch & AuthHeader;

interface PagingResponse {
    posts: Post[];
    take: number;
    skip: number;
    count: number;
}

type Response<PagingResponse>;

Base Interface

interface Base {
    createdAt: Date;
    updatedAt: Date;
}

Enumerate

enum ETripView {
    'PUBLIC' = 'public',
    'FRIEND' = 'friend',
    'SELF' = 'self',
}

enum EUserRole {
    'TRIAL' = 'trial',
    'USER' = 'user',
    'VIP1' = 'vip1',
    'VIP2' = 'vip2',
    'ADMIN' = 'admin',
}

enum EUserGender {
    'MALE' = 'male',
    'FEMALE' = 'female',
}

User Interface

interface User extends Base {
    id: string;
    role: EUserRole;
    expiredDate: Date;
    diamondCoin: number; // default 0
    goldCoin: number; // default 10
    username: string;
    email: string;
    status: boolean; // default true
    gender?: EUserGender
    age?: number;
    desc?: string;
    profileImage?: string;
    trips: Trip[];
    views: Trip[];
    posts: Post[];
    likePosts: Post[];
    followers: User[];
    followings: User[];
    blockLists: User[];
    followerCount: number;
    followingCount: number;
    version: number;
}

Trip Interface

interface Trip extends Base {
    id: string;
    startDate: Date;
    endDate: Date;
    publicStatus: ETripView;
    companyName?: string;
    shipNumber?: string;
    publisher: User;
    viewers: User[];
    version: number;
}

Post Interface

interface Post extends Base {
    id: string;
    content: string;
    images: string;
    publicStatus: ETripView;
    publisher: User;
    likeUsers: User[];
    trip: Trip;
    version: number;
}

interface FPStep3 {
    key: string;
    passowrd: string;
}

type Request = FPStep3;

export type Response<string>;

interface FPStep1 {
    email: string;
}

type Request = FPStep1;

type Response<string>;

interface FPStep2 {
    key: string;
}

type Request = FPStep2;

type Response<string>;

interface AuthHeader {
    authorization: string;
}

type Request = AuthHeader;

interface IUserInfo {
    id: string;
    role: "trial" | "user" | "vip1" | "vip2" | "admin",
    username: string;
    licence: "onepiece",
    email: string;
    expiredDate: string;
}

interface UserInformation {
    user: IUserInfo;
}

type Response<UserInformation>;

interface AuthHeader {
    authorization: string;
}

interface UserIdDto {
    id: string;
}

type Request = UserIdDto & AuthHeader;

type Response<User>;

interface ResponseBase {
  statusCode: number;
  status: 'error' | 'success';
  message: any;
  [futureKey: string]: any;
}

export type Response = ResponseBase;

interface IPage {
  take?: number;
  skip?: number;
}

interface ISearch extends IPage {
  keyword?: string;
  sort?: TSort;
  [futureKey: string]: any;
}
type Request = ISearch;

interface ResponseMessage {
    user: User[];
    take: number;
    skip: number;
    count: number;
}

type Response<ResponseMessage>;

interface FacebookCallbackInfo {
    email: string;
    username: string;
    picture: string;
    accessToken: string;
    id: string;
}

interface UserInformation {
    user: FacebookCallbackInfo;
}

type Response<UserInformation>;

interface GoogleCallbackInfo {
    email: string;
    username: string;
    picture: string;
    accessToken: string;
    id: string;
}

interface UserInformation {
    user: GoogleCallbackInfo;
}

type Response<UserInformation>;

interface SignInDto {
    email: string;
    password: string;
}

type Request = SignInDto;

type Response<string>;

interface SignUpDto {
    username: string;
    email: string;
    password: string;
}

type Request = SignUpDto;

type Response<string>;

interface AuthHeader {
    authorization: string;
}

interface DeleteById {
    id: string;
}

type Request = DeleteById & AuthHeader;

export type Response<unknown>;

enum EUserGender {
    'MALE' = 'male',
    'FEMALE' = 'female',
}

interface BufferedFile {
    fieldname: string;
    originalname: string;
    encoding: string;
    mimetype: AppMimeType;
    size: number;
    buffer: Buffer | string;
}

interface UpdateUserAdditionalInfoDto {
    gender?: EUserGender;
    age?: number;
    desc?: number;
}

interface UpdateUserAdditionalInfoInServerDto extends UpdateUserAdditionalInfoDto {
  files?: BufferedFile[];
}

type Request = UpdateUserAdditionalInfoInServerDto;

type Response<User>;

interface ResponseBase {
  statusCode: number;
  status: 'error' | 'success';
  message: any;
  [futureKey: string]: any;
}

export type Response = ResponseBase;

interface AuthHeader {
    authorization: string;
}

interface UpdatePassword {
    oldPassword: string;
    newPassword: string;
}

export type Request = UpdatePassword & AuthHeader;

type Response<string>;

interface AuthHeader {
    authorization: string;
}

type Request = AuthHeader;

type Response<string>;

Base Interface

interface Base {
    createdAt: Date;
    updatedAt: Date;
}

Enumerate

enum ETripView {
    'PUBLIC' = 'public',
    'FRIEND' = 'friend',
    'SELF' = 'self',
}

enum ELocationType {
    'COUNTRY' = 'country',
    'CITY' = 'city',
    'SCENE' = 'scene',
    'PORT' = 'port',
    'TURN' = 'turn',
}

enum EUserRole {
    'TRIAL' = 'trial',
    'USER' = 'user',
    'VIP1' = 'vip1',
    'VIP2' = 'vip2',
    'ADMIN' = 'admin',
}

enum EUserGender {
    'MALE' = 'male',
    'FEMALE' = 'female',
}

Post Interface

interface Post extends Base {
    id: string;
    content: string;
    images: string;
    publicStatus: ETripView;
    publisher: User;
    likeUsers: User[];
    trip: Trip;
    version: number;
}

Geo Interface

type Position = number[];
type GeoJsonTypes = | 
    "Point" | 
    "MultiPoint" | 
    "LineString" |
    "MultiLineString" | 
    "Polygon" | 
    "MultiPolygon" |
    "GeometryCollection";
type BBox = [number, number, number, number] | [number, number, number, number, number, number];

export type GeometryObject = Geometry;

interface GeoJsonObject {
    type: GeoJsonTypes;
    bbox?: BBox;
}

interface MultiLineString extends GeoJsonObject {
    type: "MultiLineString";
    coordinates: Position[][];
}

interface Point extends GeoJsonObject {
    type: "Point";
    coordinates: Position;
}

Trip Interface

interface Trip extends Base {
    id: string;
    startDate: Date;
    endDate: Date;
    publicStatus: ETripView;
    companyName?: string;
    shipNumber?: string;
    geom?: MultiLineString;
    publisher: User;
    viewers: User[];
    startPoint: Location;
    endPoint: Location;
    version: number;
}

Location Interface

interface Location extends Base {
    id: string;
    point: Point;
    pointSrid: Point;
    lat: number;
    lon: number;
    type: ELocationType;
    locationName: string;
    country?: Country;
    startTrips?: Trip[];
    endTrips?: Trip[];
    version: number;
}

Country Interface

interface Country extends Base {
    id: string;
    name: string;
    code: string;
}

User Interface

interface User extends Base {
    id: string;
    role: EUserRole;
    expiredDate: Date;
    diamondCoin: number; // default 0
    goldCoin: number; // default 10
    username: string;
    email: string;
    status: boolean; // default true
    gender?: EUserGender
    age?: number;
    desc?: string;
    profileImage?: string;
    trips: Trip[];
    views: Trip[];
    posts: Post[];
    likePosts: Post[];
    followers: User[];
    followings: User[];
    blockLists: User[];
    followerCount: number;
    followingCount: number;
    version: number;
}

interface AuthHeader {
    authorization: string;
}

interface CreateTripDto {
    startDate: string;
    endDate: string;
    publisherId: string;
    startPointName: string;
    endPointName: string;
    publicStatus: ETripView;
    companyName?: string;
    shipNumber?: string;
}

type Request = CreateTripDto & AuthHeader;

type Response<Trip>;

interface AuthHeader {
    authorization: string;
}

interface TripBasicDto {
    id: string;
}

interface GetTripByIdDto extends TripBasicDto {
    publisherId: string;
}

type Request = GetTripByIdDto & AuthHeader;

type Response<Trip>;

interface AuthHeader {
    authorization: string;
}

interface IPage {
  take?: number;
  skip?: number;
}

interface ISearch extends IPage {
  keyword?: string;
  sort?: TSort;
  [futureKey: string]: any;
}

interface GetTripByPagingDto extends ISearch {
    publisherId: string;
}

type Request = GetTripByPagingDto & AuthHeader;

interface PagingResponse {
    trips: Trip[],
    take: number;
    skip: number;
    count: number;
}

type Response<PagingResponse>;