linting and use db for db Models

backend/src/graphql/inputs/TransactionInput.ts

@@ -9,7 +9,7 @@ export class TransactionListInput {
   items: number
 
   @Field(() => String)
-  order: "ASC" | "DESC"
+  order: 'ASC' | 'DESC'
 }
 
 @ArgsType()

backend/src/graphql/resolvers/TransactionResolver.ts

@@ -6,8 +6,8 @@ import CONFIG from '../../config'
 import { TransactionList } from '../models/Transaction'
 import { TransactionListInput, TransactionSendArgs } from '../inputs/TransactionInput'
 import { apiGet, apiPost } from '../../apis/HttpRequest'
-import { User } from '../../typeorm/entity/User'
+import { User as dbUser } from '../../typeorm/entity/User'
-import { Balance } from '../../typeorm/entity/Balance'
+import { Balance as dbBalance } from '../../typeorm/entity/Balance'
 import listTransactions from './listTransactions'
 import { roundFloorFrom4 } from '../../util/round'
 import calculateDecay from '../../util/decay'
@@ -25,22 +25,24 @@ export class TransactionResolver {
     if (!result.success) throw new Error(result.data)
 
     // load user
-    const userEntity = await User.findByPubkeyHex(result.data.user.public_hex)
+    const userEntity = await dbUser.findByPubkeyHex(result.data.user.public_hex)
 
     const transactions = await listTransactions(firstPage, items, order, userEntity)
 
     // get gdt sum
-    const resultGDTSum = await apiPost(
+    const resultGDTSum = await apiPost(`${CONFIG.GDT_API_URL}/GdtEntries/sumPerEmailApi`, {
-      `${CONFIG.GDT_API_URL}/GdtEntries/sumPerEmailApi`, {email: userEntity.email}
+      email: userEntity.email,
-    )
+    })
     if (!resultGDTSum.success) throw new Error(resultGDTSum.data)
     transactions.gdtSum = resultGDTSum.data.sum
 
     // get balance
-    const balanceEntity = await Balance.findByUser(userEntity.id)
+    const balanceEntity = await dbBalance.findByUser(userEntity.id)
     const now = new Date()
     transactions.balance = roundFloorFrom4(balanceEntity.amount)
-    transactions.decay = roundFloorFrom4(calculateDecay(balanceEntity.amount, balanceEntity.recordDate, now))
+    transactions.decay = roundFloorFrom4(
+      calculateDecay(balanceEntity.amount, balanceEntity.recordDate, now),
+    )
     transactions.decayDate = now.toString()
 
     return transactions

backend/src/graphql/resolvers/listTransactions.ts

@@ -1,49 +1,55 @@
-
+import { User as dbUser } from '../../typeorm/entity/User'
-import { User } from '../../typeorm/entity/User'
 import { TransactionList, Transaction } from '../models/Transaction'
 import { UserTransaction } from '../../typeorm/entity/UserTransaction'
 
 function calculateAndAddDecayTransactions(
-    userTransactions:UserTransaction[],
+  userTransactions: UserTransaction[],
-    user: User, 
+  user: dbUser,
-    decay:boolean, 
+  decay: boolean,
-    skipFirstTransaction:boolean
+  skipFirstTransaction: boolean,
-): Transaction[]
+): Transaction[] {
-{
+  const transactions: Transaction[] = []
-    let transactions: Transaction[] = []
 
   return transactions
 }
 
-
 export default async function listTransactions(
-    firstPage:number,
+  firstPage: number,
-    items:number,
+  items: number,
-    order:"ASC" | "DESC",
+  order: 'ASC' | 'DESC',
-    user:User) : Promise<TransactionList>
+  user: dbUser,
-{
+): Promise<TransactionList> {
-
   let limit = items
   let offset = 0
   let skipFirstTransaction = false
-    if(firstPage > 1) {
+  if (firstPage > 1) {
-        offset = (( firstPage - 1 ) * items) - 1;
+    offset = (firstPage - 1) * items - 1
-        limit++;
+    limit++
   }
 
-    if(offset && order == 'ASC') {
+  if (offset && order === 'ASC') {
-        offset--;
+    offset--
   }
-    let [userTransactions, userTransactionsCount] = await UserTransaction.findByUserPaged(user.id, limit, offset, order)
+  let [userTransactions, userTransactionsCount] = await UserTransaction.findByUserPaged(
+    user.id,
+    limit,
+    offset,
+    order,
+  )
   skipFirstTransaction = userTransactionsCount > offset + limit
   const decay = !(firstPage > 1)
-    let transactions: Transaction[] = []
+  const transactions: Transaction[] = []
-    if(userTransactions.length) {
+  if (userTransactions.length) {
-        if(order === 'DESC') {
+    if (order === 'DESC') {
       userTransactions = userTransactions.reverse()
     }
-        let transactions = calculateAndAddDecayTransactions(userTransactions, user, decay, skipFirstTransaction)
+    let transactions = calculateAndAddDecayTransactions(
-        if(order === 'DESC') {
+      userTransactions,
+      user,
+      decay,
+      skipFirstTransaction,
+    )
+    if (order === 'DESC') {
       transactions = transactions.reverse()
     }
   }
@@ -54,7 +60,7 @@ export default async function listTransactions(
     balance: 0,
     decay: 0,
     decay_date: '',
-        transactions: transactions
+    transactions: transactions,
   })
 
   return transactionList

backend/src/typeorm/entity/User.ts

@@ -1,5 +1,4 @@
-import { BaseEntity, Entity, PrimaryGeneratedColumn, Column, OneToMany } from 'typeorm'
+import { BaseEntity, Entity, PrimaryGeneratedColumn, Column } from 'typeorm'
-import { UserTransaction } from './UserTransaction'
 
 // import { Group } from "./Group"
 

backend/src/typeorm/entity/UserTransaction.ts

@@ -1,6 +1,4 @@
-import { BaseEntity, Entity, PrimaryGeneratedColumn, Column, Timestamp, ManyToOne } from 'typeorm'
+import { BaseEntity, Entity, PrimaryGeneratedColumn, Column, Timestamp } from 'typeorm'
-import { User } from './User'
-
 
 @Entity('state_user_transactions')
 export class UserTransaction extends BaseEntity {
@@ -22,9 +20,12 @@ export class UserTransaction extends BaseEntity {
   @Column({ name: 'balance_date', type: 'timestamp' })
   balanceDate: Timestamp
 
-  static findByUserPaged(userId: number, limit: number, offset: number, order: "ASC" | "DESC")
+  static findByUserPaged(
-            :Promise<[UserTransaction[], number]>
+    userId: number,
-  {
+    limit: number,
+    offset: number,
+    order: 'ASC' | 'DESC',
+  ): Promise<[UserTransaction[], number]> {
     return this.createQueryBuilder('userTransaction')
       .where('userTransaction.userId = :userId', { userId })
       .orderBy('userTransaction.balanceDate', order)