Translated using Weblate (Vietnamese)

[github/Chocobozzz/PeerTube.git] / server / models / application / application.ts

diff --git a/server/models/application/application.ts b/server/models/application/application.ts
index 0e9a1ebb3045c331b01eea8aef76af95b7100ef7..c51ceb2454b3990344c6d7c163400abc83fa3ceb 100644 (file)
--- a/server/models/application/application.ts
+++ b/server/models/application/application.ts
@@ -1,57 +1,79 @@
-import * as Sequelize from 'sequelize'
+import memoizee from 'memoizee'
+import { AllowNull, Column, Default, DefaultScope, HasOne, IsInt, Model, Table } from 'sequelize-typescript'
+import { getNodeABIVersion } from '@server/helpers/version'
+import { AttributesOnly } from '@shared/typescript-utils'
+import { AccountModel } from '../account/account'
 
-import { addMethodsToModel } from '../utils'
-import {
-  ApplicationClass,
-  ApplicationAttributes,
-  ApplicationInstance,
+export const getServerActor = memoizee(async function () {
+  const application = await ApplicationModel.load()
+  if (!application) throw Error('Could not load Application from database.')
 
-  ApplicationMethods
-} from './application-interface'
+  const actor = application.Account.Actor
+  actor.Account = application.Account
 
-let Application: Sequelize.Model<ApplicationInstance, ApplicationAttributes>
-let loadMigrationVersion: ApplicationMethods.LoadMigrationVersion
-let updateMigrationVersion: ApplicationMethods.UpdateMigrationVersion
+  return actor
+}, { promise: true })
 
-export default function defineApplication (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
-  Application = sequelize.define<ApplicationInstance, ApplicationAttributes>('Application',
+@DefaultScope(() => ({
+  include: [
     {
-      migrationVersion: {
-        type: DataTypes.INTEGER,
-        defaultValue: 0,
-        allowNull: false,
-        validate: {
-          isInt: true
-        }
-      }
+      model: AccountModel,
+      required: true
     }
-  )
+  ]
+}))
+@Table({
+  tableName: 'application',
+  timestamps: false
+})
+export class ApplicationModel extends Model<Partial<AttributesOnly<ApplicationModel>>> {
 
-  const classMethods = [ loadMigrationVersion, updateMigrationVersion ]
-  addMethodsToModel(Application, classMethods)
+  @AllowNull(false)
+  @Default(0)
+  @IsInt
+  @Column
+  migrationVersion: number
 
-  return Application
-}
+  @AllowNull(true)
+  @Column
+  latestPeerTubeVersion: string
+
+  @AllowNull(false)
+  @Column
+  nodeVersion: string
 
-// ---------------------------------------------------------------------------
+  @AllowNull(false)
+  @Column
+  nodeABIVersion: number
 
-loadMigrationVersion = function (callback: ApplicationMethods.LoadMigrationVersionCallback) {
-  const query = {
-    attributes: [ 'migrationVersion' ]
+  @HasOne(() => AccountModel, {
+    foreignKey: {
+      allowNull: true
+    },
+    onDelete: 'cascade'
+  })
+  Account: AccountModel
+
+  static countTotal () {
+    return ApplicationModel.count()
   }
 
-  return Application.findOne(query).asCallback(function (err, data) {
-    const version = data ? data.migrationVersion : null
+  static load () {
+    return ApplicationModel.findOne()
+  }
 
-    return callback(err, version)
-  })
-}
+  static async nodeABIChanged () {
+    const application = await this.load()
 
-updateMigrationVersion = function (newVersion: number, transaction: Sequelize.Transaction, callback: ApplicationMethods.UpdateMigrationVersionCallback) {
-  const options: Sequelize.UpdateOptions = {
-    where: {},
-    transaction: transaction
+    return application.nodeABIVersion !== getNodeABIVersion()
   }
 
-  return Application.update({ migrationVersion: newVersion }, options).asCallback(callback)
+  static async updateNodeVersions () {
+    const application = await this.load()
+
+    application.nodeABIVersion = getNodeABIVersion()
+    application.nodeVersion = process.version
+
+    await application.save()
+  }
 }