# All files / src/indexer-management/resolvers poi-disputes.ts

100% Statements 16/16
100% Branches 6/6
100% Functions 10/10
100% Lines 14/14

Press n or j to go to the next uncovered block, b, p or k for the previous block.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67

    3x

    3x

    3x
    3x

    3x

    4x
    4x

    5x

    6x
    6x

    13x

    2x
    2x

    2x

     /* eslint-disable @typescript-eslint/ban-types */

    import { POIDispute, POIDisputeCreationAttributes } from '../models'
    import { IndexerManagementResolverContext } from '../client'
    import { Op } from 'sequelize'

    export default {
      dispute: async (
        { allocationID }: { allocationID: number },
        { models }: IndexerManagementResolverContext,
      ): Promise<object | null> => {
        const dispute = await models.POIDispute.findOne({
          where: { allocationID },
        })
        return dispute?.toGraphQL() || dispute
      },

      disputes: async (
        { status, minClosedEpoch }: { status: string; minClosedEpoch: number },
        { models }: IndexerManagementResolverContext,
      ): Promise<object | null> => {
        const disputes = await models.POIDispute.findAll({
          where: {
            [Op.and]: [
              { status },
              {
                closedEpoch: {
                  [Op.gte]: minClosedEpoch,
                },
              },
            ],
          },
          order: [['allocationAmount', 'DESC']],
        })
        return disputes.map((dispute) => dispute.toGraphQL())
      },

      storeDisputes: async (
        { disputes }: { disputes: POIDisputeCreationAttributes[] },
        { models }: IndexerManagementResolverContext,
      ): Promise<object | null> => {
        const createdDisputes = await models.POIDispute.bulkCreate(disputes, {
          returning: true,
          validate: true,
          updateOnDuplicate: [
            'closedEpochReferenceProof',
            'previousEpochReferenceProof',
            'status',
          ],
        })
        return createdDisputes.map((dispute: POIDispute) => dispute.toGraphQL())
      },

      deleteDisputes: async (
        { allocationIDs }: { allocationIDs: string[] },
        { models }: IndexerManagementResolverContext,
      ): Promise<number> => {
        const numDeleted = await models.POIDispute.destroy({
          where: {
            allocationID: allocationIDs,
          },
          force: true,
        })
        return numDeleted
      },
    }