query node - createdAt/updatedAt times for remaining entites

query-node/mappings/src/common.ts

@@ -2,6 +2,7 @@ import { SubstrateEvent } from '@dzlzv/hydra-common'
 import { DatabaseManager } from '@dzlzv/hydra-db-utils'
 import { u64 } from '@polkadot/types/primitive';
 import * as crypto from 'crypto'
+import { fixBlockTimestamp } from './eventFix'
 
 // Asset
 import {
@@ -77,6 +78,9 @@ export async function prepareDataObject(
     ipfsContentId: contentParameters.ipfs_content_id.toUtf8(),
     joystreamContentId: customContentParameters.content_id.encode(),
 
+    createdAt: new Date(fixBlockTimestamp(event.blockTimestamp).toNumber()),
+    updatedAt: new Date(fixBlockTimestamp(event.blockTimestamp).toNumber()),
+
     createdById: '1',
     updatedById: '1',
   })

query-node/mappings/src/content/utils.ts

@@ -13,6 +13,7 @@ import ISO6391 from 'iso-639-1'
 import { u64 } from '@polkadot/types/primitive'
 import { FindConditions } from 'typeorm'
 import * as jspb from "google-protobuf"
+import { fixBlockTimestamp } from '../eventFix'
 
 // protobuf definitions
 import {
@@ -636,6 +637,9 @@ async function prepareLanguage(
     iso: languageIso,
     createdInBlock: event.blockNumber,
 
+    createdAt: new Date(fixBlockTimestamp(event.blockTimestamp).toNumber()),
+    updatedAt: new Date(fixBlockTimestamp(event.blockTimestamp).toNumber()),
+
     // TODO: remove these lines after Hydra auto-fills the values when cascading save (remove them on all places)
     createdById: '1',
     updatedById: '1',
@@ -664,6 +668,9 @@ async function prepareLicense(
   const license = new License({
     ...licenseProtobuf,
 
+    createdAt: new Date(fixBlockTimestamp(event.blockTimestamp).toNumber()),
+    updatedAt: new Date(fixBlockTimestamp(event.blockTimestamp).toNumber()),
+
     createdById: '1',
     updatedById: '1',
   })

query-node/mappings/src/content/video.ts

@@ -276,6 +276,7 @@ export async function content_VideoUpdated(
         ? new License({
           ...originalLicense,
           ...video.license,
+          createdAt: originalLicense.createdAt, // keep original createdAt time
         }) // update existing license
         : undefined // unset license
 
@@ -437,12 +438,17 @@ function integrateVideoMediaMetadata(
     return metadata
   }
 
+  const now = new Date(fixBlockTimestamp(event.blockTimestamp).toNumber())
+
   // fix TS type
   const rawMediaMetadata = metadata.mediaMetadata as unknown as RawVideoMetadata
 
   // ensure encoding object
   const encoding = (existingRecord && existingRecord.mediaMetadata && existingRecord.mediaMetadata.encoding)
     || new VideoMediaEncoding({
+        createdAt: now,
+        updatedAt: now,
+
         createdById: '1',
         updatedById: '1',
       })
@@ -456,6 +462,9 @@ function integrateVideoMediaMetadata(
   const mediaMetadata = (existingRecord && existingRecord.mediaMetadata) || new VideoMediaMetadata({
     createdInBlock: event.blockNumber,
 
+    createdAt: now,
+    updatedAt: now,
+
     createdById: '1',
     updatedById: '1',
   })
@@ -476,6 +485,26 @@ function integrateVideoMediaMetadata(
     mediaMetadata.id = createPredictableId(event, mediaMetadata)
   }
 
+  /////////////////// update updatedAt if needed ///////////////////////////////
+
+  const encodingNoChange = true
+    && rawMediaMetadata.encoding.codecName.isNoChange()
+    && rawMediaMetadata.encoding.container.isNoChange()
+    && rawMediaMetadata.encoding.mimeMediaType.isNoChange()
+  const mediaMetadataNoChange = encodingNoChange
+    && rawMediaMetadata.encoding.codecName.isNoChange()
+    && rawMediaMetadata.encoding.container.isNoChange()
+    && rawMediaMetadata.encoding.mimeMediaType.isNoChange()
+
+  if (!encodingNoChange) { // encoding changed?
+    mediaMetadata.encoding.updatedAt = now
+  }
+  if (!mediaMetadataNoChange) { // metadata changed?
+    mediaMetadata.updatedAt = now
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+
   return {
     ...metadata,
     mediaMetadata

query-node/mappings/src/workingGroup.ts

@@ -2,6 +2,7 @@ import { SubstrateEvent } from '@dzlzv/hydra-common'
 import { DatabaseManager } from '@dzlzv/hydra-db-utils'
 import { FindConditions } from 'typeorm'
 import { Bytes } from '@polkadot/types'
+import { fixBlockTimestamp } from './eventFix'
 
 import {
   inconsistentState,
@@ -47,7 +48,7 @@ export async function storageWorkingGroup_TerminatedWorker(db: DatabaseManager,
   const {workerId} = new StorageWorkingGroup.TerminatedWorkerEvent(event).data
 
   // call generic processing
-  await workingGroup_TerminatedWorker(db, WorkerType.STORAGE, workerId)
+  await workingGroup_TerminatedWorker(db, event, WorkerType.STORAGE, workerId)
 }
 
 export async function storageWorkingGroup_WorkerExited(db: DatabaseManager, event: SubstrateEvent): Promise<void> {
@@ -55,7 +56,7 @@ export async function storageWorkingGroup_WorkerExited(db: DatabaseManager, even
   const {workerId} = new StorageWorkingGroup.WorkerExitedEvent(event).data
 
   // call generic processing
-  await workingGroup_WorkerExited(db, WorkerType.STORAGE, workerId)
+  await workingGroup_WorkerExited(db, event, WorkerType.STORAGE, workerId)
 }
 
 export async function storageWorkingGroup_TerminatedLeader(db: DatabaseManager, event: SubstrateEvent): Promise<void> {
@@ -63,7 +64,7 @@ export async function storageWorkingGroup_TerminatedLeader(db: DatabaseManager,
   const {workerId} = new StorageWorkingGroup.TerminatedLeaderEvent(event).data
 
   // call generic processing
-  await workingGroup_TerminatedLeader(db, WorkerType.STORAGE, workerId)
+  await workingGroup_TerminatedLeader(db, event, WorkerType.STORAGE, workerId)
 }
 
 /////////////////// Gateway working group //////////////////////////////////////
@@ -89,7 +90,7 @@ export async function gatewayWorkingGroup_TerminatedWorker(db: DatabaseManager,
   const {workerId} = new GatewayWorkingGroup.TerminatedWorkerEvent(event).data
 
   // call generic processing
-  await workingGroup_TerminatedWorker(db, WorkerType.GATEWAY, workerId)
+  await workingGroup_TerminatedWorker(db, event, WorkerType.GATEWAY, workerId)
 }
 
 export async function gatewayWorkingGroup_WorkerExited(db: DatabaseManager, event: SubstrateEvent): Promise<void> {
@@ -97,7 +98,7 @@ export async function gatewayWorkingGroup_WorkerExited(db: DatabaseManager, even
   const {workerId} = new GatewayWorkingGroup.WorkerExitedEvent(event).data
 
   // call generic processing
-  await workingGroup_WorkerExited(db, WorkerType.GATEWAY, workerId)
+  await workingGroup_WorkerExited(db, event, WorkerType.GATEWAY, workerId)
 }
 
 export async function gatewayWorkingGroup_TerminatedLeader(db: DatabaseManager, event: SubstrateEvent): Promise<void> {
@@ -105,7 +106,7 @@ export async function gatewayWorkingGroup_TerminatedLeader(db: DatabaseManager,
   const {workerId} = new GatewayWorkingGroup.TerminatedLeaderEvent(event).data
 
   // call generic processing
-  await workingGroup_TerminatedLeader(db, WorkerType.GATEWAY, workerId)
+  await workingGroup_TerminatedLeader(db, event, WorkerType.GATEWAY, workerId)
 }
 
 /////////////////// Generic working group processing ///////////////////////////
@@ -148,25 +149,25 @@ export async function workingGroup_WorkerStorageUpdated(db: DatabaseManager, wor
   logger.info("Worker has been updated", {workerId, workerType})
 }
 
-export async function workingGroup_TerminatedWorker(db: DatabaseManager, workerType: WorkerType, workerId: WorkerId): Promise<void> {
+export async function workingGroup_TerminatedWorker(db: DatabaseManager, event: SubstrateEvent, workerType: WorkerType, workerId: WorkerId): Promise<void> {
   // do removal logic
-  await deactivateWorker(db, workerType, workerId)
+  await deactivateWorker(db, event, workerType, workerId)
 
   // emit log event
   logger.info("Worker has been removed (worker terminated)", {workerId, workerType})
 }
 
-export async function workingGroup_WorkerExited(db: DatabaseManager, workerType: WorkerType, workerId: WorkerId): Promise<void> {
+export async function workingGroup_WorkerExited(db: DatabaseManager, event: SubstrateEvent, workerType: WorkerType, workerId: WorkerId): Promise<void> {
   // do removal logic
-  await deactivateWorker(db, workerType, workerId)
+  await deactivateWorker(db, event, workerType, workerId)
 
   // emit log event
   logger.info("Worker has been removed (worker exited)", {workerId, workerType})
 }
 
-export async function workingGroup_TerminatedLeader(db: DatabaseManager, workerType: WorkerType, workerId: WorkerId): Promise<void> {
+export async function workingGroup_TerminatedLeader(db: DatabaseManager, event: SubstrateEvent, workerType: WorkerType, workerId: WorkerId): Promise<void> {
   // do removal logic
-  await deactivateWorker(db, workerType, workerId)
+  await deactivateWorker(db, event, workerType, workerId)
 
   // emit log event
   logger.info("Working group leader has been removed (worker exited)", {workerId, workerType})
@@ -180,17 +181,22 @@ async function createWorker(
   workerType: WorkerType,
   event: SubstrateEvent,
 ): Promise<void> {
+  // create entity
   const newWorker = new Worker({
     id: createPredictableId(event, workerType),
     workerId: workerId.toString(),
     type: workerType,
     isActive: true,
+
+    createdAt: new Date(fixBlockTimestamp(event.blockTimestamp).toNumber()),
+    updatedAt: new Date(fixBlockTimestamp(event.blockTimestamp).toNumber()),
   })
 
+  // save worker
   await db.save<Worker>(newWorker)
 }
 
-async function deactivateWorker(db: DatabaseManager, workerType: WorkerType, workerId: WorkerId) {
+async function deactivateWorker(db: DatabaseManager, event: SubstrateEvent, workerType: WorkerType, workerId: WorkerId) {
   // load worker
   const worker = await db.get(Worker, {
     where: {
@@ -204,7 +210,12 @@ async function deactivateWorker(db: DatabaseManager, workerType: WorkerType, wor
     return inconsistentState('Non-existing worker deletion requested', workerId)
   }
 
+  // update worker
   worker.isActive = false
 
+  // set last update time
+  worker.updatedAt = new Date(fixBlockTimestamp(event.blockTimestamp).toNumber()),
+
+  // save worker
   await db.save<Worker>(worker)
 }