) => async (dispatch: Dispatch<Action | PublishNotificationAction>) => {
try {
const newLabels = await client.dashboards.addLabels(
dashboardID,
labels.map(l => l.id)
)
dispatch(addDashboardLabels(dashboardID, newLabels))
} catch (error) {
console.error(error)
dispatch(notify(copy.addDashboardLabelFailed()))
}
}
export const addTaskLabelsAsync = (taskID: string, labels: Label[]) => async (
dispatch
): Promise<void> => {
try {
await client.tasks.addLabels(taskID, labels.map(l => l.id))
const task = await client.tasks.get(taskID)
dispatch(updateTask(task))
} catch (error) {
console.error(error)
dispatch(notify(copy.addTaskLabelFailed()))
}
}
export const createTaskFromTemplate = (template: ITaskTemplate) => async (
dispatch,
getState: GetStateFunc
): Promise<void> => {
try {
const {
orgs: {org},
} = await getState()
await createTaskFromTemplateAJAX(template, org.id)
dispatch(getTasks())
dispatch(notify(importTaskSucceeded()))
dispatch(checkTaskLimits())
} catch (error) {
if (isLimitError(error)) {
dispatch(notify(copy.resourceLimitReached('tasks')))
} else {
dispatch(notify(importTaskFailed(error)))
}
}
}
export const deleteBucket = (id: string, name: string) => async (
dispatch: Dispatch<Action>
) => {
try {
await client.buckets.delete(id)
dispatch(removeBucket(id))
dispatch(checkBucketLimits())
} catch (e) {
console.error(e)
dispatch(notify(bucketDeleteFailed(name)))
}
}
export const addNewMember = (member: AddResourceMemberRequestBody) => async (
dispatch: Dispatch<Action>,
getState: GetState
) => {
try {
const {
orgs: {
org: {id},
},
} = getState()
const newMember = await client.organizations.addMember(id, member)
dispatch(addMember(newMember))
dispatch(notify(memberAddSuccess(member.name)))
} catch (e) {
console.error(e)
const message = _.get(e, 'response.data.message', 'Unknown error')
dispatch(notify(memberAddFailed(message)))
throw e
}
}
export const selectTaskByID = (id: string) => async (
dispatch
): Promise<void> => {
try {
const task = await client.tasks.get(id)
dispatch(setCurrentTask(task))
} catch (e) {
console.error(e)
dispatch(goToTasks())
const message = getErrorMessage(e)
dispatch(notify(taskNotFound(message)))
}
}
export const convertToTemplate = (taskID: string) => async (
dispatch
): Promise<void> => {
try {
dispatch(setExportTemplate(RemoteDataState.Loading))
const task = await client.tasks.get(taskID)
const taskTemplate = taskToTemplate(task)
dispatch(setExportTemplate(RemoteDataState.Done, taskTemplate))
} catch (error) {
dispatch(setExportTemplate(RemoteDataState.Error))
dispatch(notify(copy.createTemplateFailed(error)))
}
}
export const executeQueries = () => async (dispatch, getState: GetState) => {
const {view, timeRange} = getActiveTimeMachine(getState())
const queries = view.properties.queries.filter(({text}) => !!text.trim())
if (!queries.length) {
dispatch(setQueryResults(RemoteDataState.Done, [], null))
}
try {
dispatch(setQueryResults(RemoteDataState.Loading, null, null, null))
await dispatch(refreshTimeMachineVariableValues())
const orgID = getState().orgs.org.id
const activeTimeMachineID = getState().timeMachines.activeTimeMachineID
const variableAssignments = [
...getVariableAssignments(getState(), activeTimeMachineID),
...getTimeRangeVars(timeRange),
]
const startTime = Date.now()
pendingResults.forEach(({cancel}) => cancel())
pendingResults = queries.map(({text}) =>
executeQueryWithVars(orgID, text, variableAssignments)
)
const results = await Promise.all(pendingResults.map(r => r.promise))
const duration = Date.now() - startTime
const files = results.map(r => r.csv)
files.forEach(checkQueryResult)
dispatch(setQueryResults(RemoteDataState.Done, files, duration))
} catch (e) {
if (e instanceof CancellationError) {
return
}
if (get(e, 'status') === RATE_LIMIT_ERROR_STATUS) {
const retryAfter = get(e, 'headers.Retry-After')
dispatch(notify(rateLimitReached(retryAfter)))
}
console.error(e)
dispatch(setQueryResults(RemoteDataState.Error, null, null, e.message))
}
}
export const cloneTemplate = (templateID: string) => async (
dispatch,
getState: GetState
): Promise<void> => {
try {
const {
orgs: {org},
} = getState()
const createdTemplate = await client.templates.clone(templateID, org.id)
dispatch(
addTemplateSummary({
...createdTemplate,
labels: createdTemplate.labels || [],
})
)
dispatch(notify(copy.cloneTemplateSuccess()))
} catch (e) {
console.error(e)
dispatch(notify(copy.cloneTemplateFailed(e)))
}
}
) => async (dispatch: Dispatch<Action>): Promise<void> => {
try {
const clonedCell = getClonedDashboardCell(dashboard, cell)
const updatedDashboard = {
...dashboard,
cells: [...dashboard.cells, clonedCell],
}
dispatch(loadDashboard(updatedDashboard))
dispatch(notify(copy.cellAdded()))
} catch (error) {
console.error(error)
}
}
