fixed issue that daterangepicker not editable

fixed issue that prize amount missing 'USD' suffix
fixed issue that dropdownTerms missing small size
updated lint-fix

Author: nqviet

src/actions/challenges.js

@@ -8,32 +8,69 @@ async function doGetChallenges(filter) {
 }
 
 async function getAllActiveChallenges(filter) {
-  const activeFilter = {
+  const BUCKET_ALL_ACTIVE_CHALLENGES = constants.FILTER_BUCKETS[0];
+  let page;
+
+  if (util.isDisplayingBucket(filter, BUCKET_ALL_ACTIVE_CHALLENGES)) {
+    page = filter.page;
+  } else {
+    page = 1;
+  }
+
+  const allActiveFilter = {
     ...util.createChallengeCriteria(filter),
     ...util.createAllActiveChallengeCriteria(),
+    page,
   };
-  return doGetChallenges(activeFilter);
+  return doGetChallenges(allActiveFilter);
 }
 
 async function getOpenForRegistrationChallenges(filter) {
+  const BUCKET_OPEN_FOR_REGISTRATION = constants.FILTER_BUCKETS[1];
+  let page;
+
+  if (util.isDisplayingBucket(filter, BUCKET_OPEN_FOR_REGISTRATION)) {
+    page = filter.page;
+  } else {
+    page = 1;
+  }
+
   const openForRegistrationFilter = {
     ...util.createChallengeCriteria(filter),
     ...util.createOpenForRegistrationChallengeCriteria(),
+    page,
   };
   return doGetChallenges(openForRegistrationFilter);
 }
 
 async function getClosedChallenges(filter) {
-  const pastFilter = {
+  const BUCKET_CLOSED_CHALLENGES = constants.FILTER_BUCKETS[1];
+  let page;
+
+  if (util.isDisplayingBucket(filter, BUCKET_CLOSED_CHALLENGES)) {
+    page = filter.page;
+  } else {
+    page = 1;
+  }
+
+  const closedFilter = {
     ...util.createChallengeCriteria(filter),
     ...util.createClosedChallengeCriteria(),
+    page,
   };
-  return doGetChallenges(pastFilter);
+  return doGetChallenges(closedFilter);
 }
 
 async function getRecommendedChallenges(filter) {
-  const result = []
-  result.meta = { total: 0 }
+  let result = [];
+  result.meta = { total: 0 };
+
+  if (result.length === 0) {
+    const failbackFilter = { ...filter };
+    result = await getOpenForRegistrationChallenges(failbackFilter);
+    result.loadingRecommendedChallengesError = true;
+  }
+
   return result;
 }
 
@@ -51,35 +88,58 @@ async function getChallenges(filter, change) {
   const FILTER_BUCKETS = constants.FILTER_BUCKETS;
   const BUCKET_ALL_ACTIVE_CHALLENGES = FILTER_BUCKETS[0];
   const BUCKET_OPEN_FOR_REGISTRATION = FILTER_BUCKETS[1];
-  const BUCKET_PAST_CHALLENGES = FILTER_BUCKETS[2];
+  const BUCKET_CLOSED_CHALLENGES = FILTER_BUCKETS[2];
   const filterChange = change;
   const bucket = filter.bucket;
 
   const getChallengesByBuckets = async (f) => {
     return FILTER_BUCKETS.includes(f.bucket)
       ? Promise.all([
-        getAllActiveChallenges(f),
-        f.recommended ? getRecommendedChallenges() : getOpenForRegistrationChallenges(f),
-        getClosedChallenges(f)
-      ])
-      : [[], [], []]
+          getAllActiveChallenges(f),
+          f.recommended
+            ? getRecommendedChallenges(f)
+            : getOpenForRegistrationChallenges(f),
+          getClosedChallenges(f),
+        ])
+      : [[], [], []];
   };
 
   if (!filterChange) {
-    let [allActiveChallenges, openForRegistrationChallenges, closedChallenges] = await getChallengesByBuckets(filter)
+    let [
+      allActiveChallenges,
+      openForRegistrationChallenges,
+      closedChallenges,
+    ] = await getChallengesByBuckets(filter);
     let challenges;
     let openForRegistrationCount;
     let total;
+    let loadingRecommendedChallengesError;
 
     switch (bucket) {
-      case BUCKET_ALL_ACTIVE_CHALLENGES: challenges = allActiveChallenges; break;
-      case BUCKET_OPEN_FOR_REGISTRATION: challenges = openForRegistrationChallenges; break;
-      case BUCKET_PAST_CHALLENGES: challenges = closedChallenges; break;
+      case BUCKET_ALL_ACTIVE_CHALLENGES:
+        challenges = allActiveChallenges;
+        break;
+      case BUCKET_OPEN_FOR_REGISTRATION:
+        challenges = openForRegistrationChallenges;
+        break;
+      case BUCKET_CLOSED_CHALLENGES:
+        challenges = closedChallenges;
+        break;
     }
     openForRegistrationCount = openForRegistrationChallenges.meta.total;
     total = challenges.meta.total;
-
-    return { challenges, total, openForRegistrationCount, allActiveChallenges, openForRegistrationChallenges, closedChallenges };
+    loadingRecommendedChallengesError =
+      challenges.loadingRecommendedChallengesError;
+
+    return {
+      challenges,
+      total,
+      openForRegistrationCount,
+      loadingRecommendedChallengesError,
+      allActiveChallenges,
+      openForRegistrationChallenges,
+      closedChallenges,
+    };
   }
 
   if (!util.checkRequiredFilterAttributes(filter)) {
@@ -92,26 +152,47 @@ async function getChallenges(filter, change) {
   let challenges;
   let openForRegistrationCount;
   let total;
+  let loadingRecommendedChallengesError;
 
   if (util.shouldFetchChallenges(filterChange)) {
-    [allActiveChallenges, openForRegistrationChallenges, closedChallenges] = await getChallengesByBuckets(filter)
+    [
+      allActiveChallenges,
+      openForRegistrationChallenges,
+      closedChallenges,
+    ] = await getChallengesByBuckets(filter);
     switch (bucket) {
-      case BUCKET_ALL_ACTIVE_CHALLENGES: challenges = allActiveChallenges; break;
-      case BUCKET_OPEN_FOR_REGISTRATION: challenges = openForRegistrationChallenges; break;
-      case BUCKET_PAST_CHALLENGES: challenges = closedChallenges; break;
+      case BUCKET_ALL_ACTIVE_CHALLENGES:
+        challenges = allActiveChallenges;
+        break;
+      case BUCKET_OPEN_FOR_REGISTRATION:
+        challenges = openForRegistrationChallenges;
+        break;
+      case BUCKET_CLOSED_CHALLENGES:
+        challenges = closedChallenges;
+        break;
     }
   }
 
   openForRegistrationCount = openForRegistrationChallenges.meta.total;
   total = challenges.meta.total;
+  loadingRecommendedChallengesError =
+    challenges.loadingRecommendedChallengesError;
 
   if (util.shouldFilterChallenges(filterChange)) {
     challenges = doFilterBySubSommunities(challenges);
     challenges = doFilterByPrizeFrom(challenges);
     challenges = doFilterByPrizeTo(challenges);
   }
 
-  return { challenges, total, openForRegistrationCount, allActiveChallenges, openForRegistrationChallenges, closedChallenges };
+  return {
+    challenges,
+    total,
+    openForRegistrationCount,
+    loadingRecommendedChallengesError,
+    allActiveChallenges,
+    openForRegistrationChallenges,
+    closedChallenges,
+  };
 }
 
 export default createActions({

src/actions/filter.js

@@ -1,6 +1,6 @@
 import { createActions } from "redux-actions";
 
-function restoreFilter (filter) {
+function restoreFilter(filter) {
   return filter;
 }
 

src/components/Button/index.jsx

@@ -18,16 +18,13 @@ const ButtonIcon = ({ children, onClick }) => (
   <button styleName="button-icon" onClick={onClick} type="button">
     {children}
   </button>
-)
+);
 
 ButtonIcon.propTypes = {
   children: PT.node,
   onClick: PT.func,
 };
 
-export {
-  Button,
-  ButtonIcon,
-}
+export { Button, ButtonIcon };
 
 export default Button;

src/components/Checkbox/index.jsx

@@ -23,8 +23,8 @@ function Checkbox({ checked, onChange, size, errorMsg }) {
   ).current;
 
   useEffect(() => {
-    setCheckedInternal(checked)
-  }, [checked])
+    setCheckedInternal(checked);
+  }, [checked]);
 
   return (
     <label styleName={`container ${sizeStyle}`}>