TypeScript api.client.labels類代碼示例

const createLabelsFromTemplate = async <T extends TemplateBase>(
  template: T,
  orgID: string
): Promise<LabelMap> => {
  const {
    content: {data, included},
  } = template

  const labeledResources = [data, ...included].filter(r =>
    hasLabelsRelationships(r)
  )

  if (_.isEmpty(labeledResources)) {
    return {}
  }

  const labelRelationships = _.flatMap(labeledResources, r =>
    getLabelRelationships(r)
  )

  const includedLabels = findIncludedsFromRelationships<LabelIncluded>(
    included,
    labelRelationships
  )

  const existingLabels = await client.labels.getAll(orgID)

  const labelsToCreate = findLabelsToCreate(existingLabels, includedLabels).map(
    l => ({
      orgID,
      name: _.get(l, 'attributes.name', ''),
      properties: _.get(l, 'attributes.properties', {}),
    })
  )

  const createdLabels = await client.labels.createAll(labelsToCreate)
  const allLabels = [...createdLabels, ...existingLabels]

  const labelMap: LabelMap = {}

  includedLabels.forEach(label => {
    const createdLabel = allLabels.find(l => l.name === label.attributes.name)

    labelMap[label.id] = createdLabel.id
  })

  return labelMap
}

export const deleteLabel = (id: string) => async (
  dispatch: Dispatch<Action>
) => {
  try {
    await client.labels.delete(id)

    dispatch(removeLabel(id))
  } catch (e) {
    console.error(e)
    dispatch(notify(deleteLabelFailed()))
  }
}

const createTelegraf = async (dispatch, getState, plugins) => {
  try {
    const {
      dataLoading: {
        dataLoaders: {telegrafConfigName, telegrafConfigDescription},
        steps: {bucket, orgID, bucketID},
      },
    } = getState()

    const telegrafRequest: TelegrafRequest = {
      name: telegrafConfigName,
      description: telegrafConfigDescription,
      agent: {collectionInterval: DEFAULT_COLLECTION_INTERVAL},
      organizationID: orgID,
      plugins,
    }

    // create telegraf config
    const tc = await client.telegrafConfigs.create(telegrafRequest)

    const permissions = [
      {
        action: Permission.ActionEnum.Write,
        resource: {
          type: PermissionResource.TypeEnum.Buckets,
          id: bucketID,
          orgID,
        },
      },
      {
        action: Permission.ActionEnum.Read,
        resource: {
          type: PermissionResource.TypeEnum.Telegrafs,
          id: tc.id,
          orgID,
        },
      },
    ]

    const token = {
      name: `${telegrafConfigName} token`,
      orgID,
      description: `WRITE ${bucket} bucket / READ ${telegrafConfigName} telegraf config`,
      permissions,
    }

    // create token
    const createdToken = await createAuthorization(token)

    // add token to data loader state
    dispatch(setToken(createdToken.token))

    // add token to authorizations state
    dispatch(addAuthorization(createdToken))

    // create token label
    const properties = {
      color: '#FFFFFF',
      description: `token for telegraf config: ${telegrafConfigName}`,
      tokenID: createdToken.id,
    } as ILabelProperties // hack to make compiler work

    const createdLabel = await client.labels.create({
      orgID,
      name: '@influxdata.token',
      properties,
    })

    // add label to telegraf config
    const label = await client.telegrafConfigs.addLabel(tc.id, createdLabel)

    const config = {
      ...tc,
      labels: [label],
    }

    dispatch(setTelegrafConfigID(tc.id))
    dispatch(addTelegraf(config))
    dispatch(notify(TelegrafConfigCreationSuccess))
  } catch (error) {
    dispatch(notify(TelegrafConfigCreationError))
  }
}