SCM-Manager/scm-ui/src/repos/modules/branches.js

// @flow
import {
  FAILURE_SUFFIX,
  PENDING_SUFFIX,
  SUCCESS_SUFFIX
} from "../../modules/types";
import { apiClient } from "@scm-manager/ui-components";

export const FETCH_BRANCHES = "scm/repos/FETCH_BRANCHES";
export const FETCH_BRANCHES_PENDING = `${FETCH_BRANCHES}_${PENDING_SUFFIX}`;
export const FETCH_BRANCHES_SUCCESS = `${FETCH_BRANCHES}_${SUCCESS_SUFFIX}`;
export const FETCH_BRANCHES_FAILURE = `${FETCH_BRANCHES}_${FAILURE_SUFFIX}`;

const REPO_URL = "repositories";

// Fetching branches
export function fetchBranchesByNamespaceAndName(
  namespace: string,
  name: string
) {
  return function(dispatch: any) {
    dispatch(fetchBranchesPending(namespace, name));
    return apiClient
      .get(REPO_URL + "/" + namespace + "/" + name + "/branches")
      .then(response => response.json())
      .then(data => {
        dispatch(fetchBranchesSuccess(data, namespace, name));
      })
      .catch(error => {
        dispatch(fetchBranchesFailure(namespace, name, error));
      });
  };
}

// Action creators
export function fetchBranchesPending(namespace: string, name: string) {
  return {
    type: FETCH_BRANCHES_PENDING,
    payload: { namespace, name },
    itemId: namespace + "/" + name
  };
}

export function fetchBranchesSuccess(
  data: string,
  namespace: string,
  name: string
) {
  return {
    type: FETCH_BRANCHES_SUCCESS,
    payload: { data, namespace, name },
    itemId: namespace + "/" + name
  };
}

export function fetchBranchesFailure(
  namespace: string,
  name: string,
  error: Error
) {
  return {
    type: FETCH_BRANCHES_FAILURE,
    payload: { error, namespace, name },
    itemId: namespace + "/" + name
  };
}

// Reducers

export default function reducer(
  state: Object = {},
  action: Action = { type: "UNKNOWN" }
): Object {
  switch (action.type) {
    case FETCH_BRANCHES_SUCCESS:
      const key = action.payload.namespace + "/" + action.payload.name;
      let oldBranchesByNames = { [key]: {} };
      if (state[key] !== undefined) {
        oldBranchesByNames[key] = state[key];
      }
      return {
        [key]: {
          byNames: extractBranchesByNames(
            action.payload.data,
            oldBranchesByNames[key].byNames
          )
        }
      };
    default:
      return state;
  }
}

function extractBranchesByNames(data: any, oldBranchesByNames: any): Branch[] {
  const branches = data._embedded.branches;
  const branchesByNames = {};

  for (let branch of branches) {
    branchesByNames[branch.name] = branch;
  }

  for (let name in oldBranchesByNames) {
    branchesByNames[name] = oldBranchesByNames[name];
  }
  return branchesByNames;
}

// Selectors

export function getBranchesForNamespaceAndNameFromState(
  namespace: string,
  name: string,
  state: Object
) {
  const key = namespace + "/" + name;
  if (!state.branches[key]) {
    return null;
  }
  return Object.values(state.branches[key].byNames);
}

export function getBranchNames(namespace: string, name: string, state: Object) {
  const key = namespace + "/" + name;
  if (!state.branches[key] || !state.branches[key].byNames) {
    return null;
  }
  return Object.keys(state.branches[key].byNames);
}