flexor-web/src/actions/registration.ts

import { Action, AnyAction } from 'redux'
import { ThunkAction } from 'redux-thunk'

import { setFieldNotification } from 'src/actions/forms'
import { startRequest, finishRequest } from 'src/actions/requests'
import { createGroup as fetchCreateGroup } from 'src/api/groups'
import { fetchGroupAvailability, register as fetchRegister } from 'src/api/registration'

import {
    LOCAL_STORAGE_ACCESS_TOKEN_KEY,
    LOCAL_STORAGE_ACCESS_TOKEN_AT_KEY,
    LOCAL_STORAGE_REFRESH_TOKEN_KEY,
} from 'src/constants'
import { AppState, AppThunkAction } from 'src/types'

const FETCH_GROUP_AVAILABILITY_ID = 'FETCH_GROUP_AVAILABILITY'
const FETCH_USER_AVAILABILITY_ID = 'FETCH_USER_AVAILABILITY'
const CREATE_GROUP_ID = 'CREATE_GROUP'
const REGISTER_ID = 'REGISTER'

export interface SetStepAction extends Action {
    type: 'REGISTRATION_SET_STEP'
    payload: number
}

export type RegistrationActions = SetStepAction

export const setStep = (step: number): SetStepAction => ({
    type: 'REGISTRATION_SET_STEP',
    payload: step,
})

export const checkGroupAvailability = (name: string): AppThunkAction => {
    return async dispatch => {
        dispatch(startRequest(FETCH_GROUP_AVAILABILITY_ID))

        try {
            const response = await fetchGroupAvailability(name)

            if (response.available) {
                dispatch(setFieldNotification('group-name', 'success', `${response.id} is available`))
            } else {
                dispatch(setFieldNotification('group-name', 'error', `${response.id} isn't available`))
            }

            dispatch(finishRequest(FETCH_GROUP_AVAILABILITY_ID, true))
        } catch (err) {
            dispatch(finishRequest(FETCH_GROUP_AVAILABILITY_ID, false))
            throw err
        }
    }
}

export const checkUserAvailability = (name: string): AppThunkAction => {
    return async dispatch => {
        dispatch(startRequest(FETCH_USER_AVAILABILITY_ID))

        try {
            const { id, available } = await fetchGroupAvailability(name)

            if (available) {
                dispatch(setFieldNotification('user-id', 'success', `${id} is available`))
            } else {
                dispatch(setFieldNotification('user-id', 'error', `${id} isn't available`))
            }

            dispatch(finishRequest(FETCH_USER_AVAILABILITY_ID, true))
        } catch (err) {
            dispatch(finishRequest(FETCH_USER_AVAILABILITY_ID, false))
            throw err
        }
    }
}

export const createGroup = (name: string, registration: string, about?: string): ThunkAction<Promise<string>, AppState, void, AnyAction> => {
    return async dispatch => {
        dispatch(startRequest(CREATE_GROUP_ID))

        try {
            const { id } = await fetchCreateGroup(name, registration, about)
            dispatch(finishRequest(CREATE_GROUP_ID, true))

            return id
        } catch (err) {
            dispatch(finishRequest(CREATE_GROUP_ID, false))
            throw err
        }
    }
}

export const register = (id: string, email: string, password: string, name?: string, group?: string): ThunkAction<Promise<string>, AppState, void, AnyAction> => {
    return async dispatch => {
        dispatch(startRequest(REGISTER_ID))

        try {
            const response = await fetchRegister(id, email, password, name, group)
            dispatch(finishRequest(REGISTER_ID, true))

            localStorage.setItem(LOCAL_STORAGE_ACCESS_TOKEN_KEY, response.access)
            localStorage.setItem(LOCAL_STORAGE_REFRESH_TOKEN_KEY, response.refresh)

            return response.id
        } catch (err) {
            dispatch(finishRequest(REGISTER_ID, false))
            throw err
        }
    }
}