name: selectLocalizedContent()

in src/amo/actions/reviews.js [89:306]

• 121 lines of code
• 6 McCabe index (conditional complexity)

      name: selectLocalizedContent(review.addon.name, lang),
      slug: review.addon.slug,
    },
    body: review.body,
    created: review.created,
    id: review.id,
    isDeleted: review.is_deleted,
    isDeveloperReply: review.is_developer_reply,
    isLatest: review.is_latest,
    score: review.score || null,
    reply: review.reply ? createInternalReview(review.reply, lang) : null,
    userId: review.user.id,
    userName: review.user.name,
    userUrl: review.user.url,
    versionId: review.version ? review.version.id : null,
  };
}

export type SetReviewAction = {|
  type: typeof SET_REVIEW,
  payload: ExternalReviewType,
|};

export const setReview = (review: ExternalReviewType): SetReviewAction => {
  invariant(review, 'review is required');

  return { type: SET_REVIEW, payload: review };
};

type SetReviewReplyParams = {|
  originalReviewId: number,
  reply: ExternalReviewReplyType,
|};

export type SetReviewReplyAction = {|
  type: typeof SET_REVIEW_REPLY,
  payload: SetReviewReplyParams,
|};

export const setReviewReply = ({
  originalReviewId,
  reply,
}: SetReviewReplyParams): SetReviewReplyAction => {
  if (!originalReviewId) {
    throw new Error('The originalReviewId parameter is required');
  }
  if (!reply) {
    throw new Error('The reply parameter is required');
  }
  return {
    type: SET_REVIEW_REPLY,
    payload: { originalReviewId, reply },
  };
};

type FetchReviewParams = {|
  errorHandlerId: string,
  reviewId: number,
|};

export type FetchReviewAction = {|
  type: typeof FETCH_REVIEW,
  payload: {|
    errorHandlerId: string,
    reviewId: number,
  |},
|};

export function fetchReview({
  errorHandlerId,
  reviewId,
}: FetchReviewParams): FetchReviewAction {
  invariant(errorHandlerId, 'errorHandlerId is required');
  invariant(reviewId, 'reviewId is required');

  return {
    type: FETCH_REVIEW,
    payload: { errorHandlerId, reviewId },
  };
}

type FetchReviewsParams = {|
  addonSlug: string,
  errorHandlerId: string,
  page?: string,
  score: string | null,
|};

export type FetchReviewsAction = {|
  type: typeof FETCH_REVIEWS,
  payload: {|
    addonSlug: string,
    errorHandlerId: string,
    page: string,
    score: string | null,
  |},
|};

export function fetchReviews({
  addonSlug,
  errorHandlerId,
  page = '1',
  score,
}: FetchReviewsParams): FetchReviewsAction {
  if (!errorHandlerId) {
    throw new Error('errorHandlerId cannot be empty');
  }
  if (!addonSlug) {
    throw new Error('addonSlug cannot be empty');
  }
  return {
    type: FETCH_REVIEWS,
    payload: { addonSlug, errorHandlerId, page, score },
  };
}

type FetchReviewPermissionsParams = {|
  errorHandlerId: string,
  addonId: number,
  userId: UserId,
|};

export type FetchReviewPermissionsAction = {|
  type: typeof FETCH_REVIEW_PERMISSIONS,
  payload: FetchReviewPermissionsParams,
|};

export function fetchReviewPermissions({
  errorHandlerId,
  addonId,
  userId,
}: FetchReviewPermissionsParams): FetchReviewPermissionsAction {
  invariant(errorHandlerId, 'errorHandlerId is required');
  invariant(addonId, 'addonId is required');
  invariant(userId, 'userId is required');

  return {
    type: FETCH_REVIEW_PERMISSIONS,
    payload: { errorHandlerId, addonId, userId },
  };
}

type SetReviewPermissionsParams = {|
  addonId: number,
  userId: UserId,
  canReplyToReviews: boolean,
|};

export type SetReviewPermissionsAction = {|
  type: typeof SET_REVIEW_PERMISSIONS,
  payload: SetReviewPermissionsParams,
|};

export function setReviewPermissions({
  addonId,
  userId,
  canReplyToReviews,
}: SetReviewPermissionsParams): SetReviewPermissionsAction {
  invariant(addonId, 'addonId is required');
  invariant(userId, 'userId is required');
  invariant(
    typeof canReplyToReviews !== 'undefined',
    'canReplyToReviews is required',
  );

  return {
    type: SET_REVIEW_PERMISSIONS,
    payload: { addonId, userId, canReplyToReviews },
  };
}

type UpdateRatingCountsParams = {|
  addonId: number,
  oldReview?: UserReviewType,
  newReview: UserReviewType,
|};

export type UpdateRatingCountsAction = {|
  type: typeof UPDATE_RATING_COUNTS,
  payload: UpdateRatingCountsParams,
|};

export function updateRatingCounts({
  addonId,
  oldReview,
  newReview,
}: UpdateRatingCountsParams): UpdateRatingCountsAction {
  invariant(addonId, 'addonId is required');
  invariant(newReview, 'newReview is required');
  return {
    type: UPDATE_RATING_COUNTS,
    payload: { addonId, oldReview, newReview },
  };
}

type FetchLatestUserReviewParams = {|
  addonId: number,
  errorHandlerId: string,
  userId: UserId,
|};

export type FetchLatestUserReviewAction = {|
  type: typeof FETCH_LATEST_USER_REVIEW,
  payload: FetchLatestUserReviewParams,
|};

export function fetchLatestUserReview({
  addonId,
  errorHandlerId,
  userId,
}: FetchLatestUserReviewParams): FetchLatestUserReviewAction {
  invariant(addonId, 'addonId is required');
  invariant(errorHandlerId, 'errorHandlerId is required');
  invariant(userId, 'userId is required');

  return {
    type: FETCH_LATEST_USER_REVIEW,
    payload: {