diff --git a/src/components/Challenge/AvailableChallengeDetailsView.tsx b/src/components/Challenge/AvailableChallengeDetailsView.tsx
deleted file mode 100644
index 791bb3bf9126d4ab889cc6f3de2d0232b9f901ec..0000000000000000000000000000000000000000
--- a/src/components/Challenge/AvailableChallengeDetailsView.tsx
+++ /dev/null
@@ -1,279 +0,0 @@
-import React, { useState, useEffect, useCallback } from 'react'
-import { useI18n } from 'cozy-ui/transpiled/react/I18n'
-import { useClient } from 'cozy-client'
-import { Redirect } from 'react-router-dom'
-import { useRecoilState, useRecoilValue } from 'recoil'
-import { DateTime } from 'luxon'
-import { Location } from 'history'
-
-import { ScreenType } from 'enum/screen.enum'
-import { ChallengeType, UserProfile } from 'models'
-import { userProfileState } from 'atoms/userProfile.state'
-import { screenTypeState } from 'atoms/screenType.state'
-import { fluidTypeState } from 'atoms/fluidState.state'
-import { currentChallengeState } from 'atoms/challenge.state'
-import ChallengeService from 'services/challenge.service'
-import ConsumptionService from 'services/consumption.service'
-import UserProfileService from 'services/userProfile.service'
-import { getLagDays } from 'utils/date'
-
-import CozyBar from 'components/Header/CozyBar'
-import Header from 'components/Header/Header'
-import Content from 'components/Content/Content'
-import { history } from 'components/App'
-import StyledSpinner from 'components/CommonKit/Spinner/StyledSpinner'
-import StyledButtonValid from 'components/CommonKit/Button/StyledButtonValid'
-import AvailableChallengeIcon from 'assets/png/badges/available-big.png'
-import { FluidType } from 'enum/fluid.enum'
-import warningWhite from 'assets/icons/ico/warning-white.svg'
-import StyledIcon from 'components/CommonKit/Icon/StyledIcon'
-
-interface AvailableChallengeDetailsViewProps {
- location: Location<ChallengeType>
-}
-interface LackOfFluidData {
- fluidType: Array<number>
- periode: {
- endDate: DateTime
- startDate: DateTime
- }
-}
-
-const AvailableChallengeDetailsView: React.FC<AvailableChallengeDetailsViewProps> = ({
- location,
-}: AvailableChallengeDetailsViewProps) => {
- const { t } = useI18n()
- const client = useClient()
-
- const screenType = useRecoilValue(screenTypeState)
- const fluidTypes = useRecoilValue(fluidTypeState)
- const [userProfile, setUserProfile] = useRecoilState<UserProfile>(
- userProfileState
- )
- const [currentChallenge, setCurrentChallenge] = useRecoilState(
- currentChallengeState
- )
-
- const challengeState = location.state
- const [redirect, setRedirect] = useState(false)
- const [challenge, setChallenge] = useState<ChallengeType | null>(null)
- const [headerHeight, setHeaderHeight] = useState<number>(0)
- const [lackOfDataForChallenge, setLackOfDataForChallenge] = useState<boolean>(
- false
- )
- const [noConnecteur, setNoConnecteur] = useState<boolean>(false)
- const [lackOfDataFluidtype, setLackOfDataFluidtype] = useState<
- LackOfFluidData
- >({
- fluidType: [],
- periode: {},
- })
- const [isLoaded, setIsLoaded] = useState<boolean>(false)
-
- const challengeService = new ChallengeService(client)
-
- const defineHeaderHeight = (height: number) => {
- setHeaderHeight(height)
- }
-
- const updateUserProfileNotification = useCallback(
- async (ecogestureList: string[]) => {
- const userProfileService = new UserProfileService(client)
- await userProfileService
- .updateUserProfile({ notificationEcogesture: ecogestureList })
- .then(updatedUserProfile => {
- updatedUserProfile && setUserProfile(updatedUserProfile)
- })
- },
- [setUserProfile]
- )
-
- async function startChallenge() {
- if (challenge) {
- const startedChallenge = await challengeService.startChallenge(
- challenge,
- fluidTypes,
- challenge.availableEcogestures
- )
- setCurrentChallenge(startedChallenge)
- const updatedNotificationEcogestureList: string[] = userProfile.notificationEcogesture
- ? [...userProfile.notificationEcogesture]
- : []
- if (startedChallenge && updatedNotificationEcogestureList) {
- updatedNotificationEcogestureList.push(
- startedChallenge.selectedEcogestures[0].id
- )
- updatedNotificationEcogestureList.push(
- startedChallenge.selectedEcogestures[1].id
- )
- await updateUserProfileNotification(updatedNotificationEcogestureList)
- }
- }
- }
-
- async function handleStartClick() {
- await startChallenge()
- setRedirect(true)
- }
-
- const renderRedirect = () => {
- if (redirect) {
- return (
- <Redirect
- to={{
- pathname: '/challenges/ongoing',
- state: currentChallenge,
- }}
- />
- )
- }
- }
-
- useEffect(() => {
- let subscribed = true
- async function checkPreviousData() {
- const lag = getLagDays(fluidTypes)
- const firstDayOfPreviousPeriod = challengeState.duration.days
- const timePeriod = {
- startDate: DateTime.local()
- .plus({ days: -firstDayOfPreviousPeriod - lag })
- .startOf('day'),
- endDate: DateTime.local()
- .plus({ days: -lag })
- .endOf('day'),
- }
- const consumptionService = new ConsumptionService(client)
- const fetchedPerformanceIndicators = await consumptionService.getPerformanceIndicators(
- timePeriod,
- 20,
- fluidTypes
- )
- if (fetchedPerformanceIndicators.length !== 0 && subscribed) {
- let i = 0
- const listFluid: Array<FluidType> = []
- fetchedPerformanceIndicators.forEach(element => {
- if (!element.value) {
- const idFluid = fluidTypes[i]
- listFluid.push(idFluid)
- //getFluidName
- setLackOfDataForChallenge(true)
- }
- i += 1
- setLackOfDataFluidtype({
- fluidType: listFluid,
- periode: timePeriod,
- })
- })
- } else {
- setLackOfDataForChallenge(true)
- setNoConnecteur(true)
- }
- setIsLoaded(true)
- }
- if (challengeState && subscribed) {
- checkPreviousData()
- setChallenge(challengeState)
- }
- return () => {
- subscribed = false
- }
- }, [])
- return (
- <React.Fragment>
- <CozyBar
- titleKey={'COMMON.APP_NEW_CHALLENGE_TITLE'}
- displayBackArrow={true}
- />
- <Header
- setHeaderHeight={defineHeaderHeight}
- desktopTitleKey={'COMMON.APP_NEW_CHALLENGE_TITLE'}
- displayBackArrow={true}
- ></Header>
- {!challengeState ? <Redirect to="/challenges" /> : null}
- <Content height={headerHeight} background="var(--darkLight2)">
- {!challenge ? (
- <StyledSpinner />
- ) : (
- <>
- <div className="cp-root --available">
- <div className="cp-content">
- <div className="cp-info --available">
- <div className="cp-title text-22-bold">{challenge.title}</div>
- <img
- className="cp-icon"
- src={AvailableChallengeIcon}
- width={screenType === ScreenType.MOBILE ? 180 : 300}
- ></img>
- <div className="cp-description text-16-bold">
- {challenge.description}
- </div>
- <div>
- {lackOfDataForChallenge && isLoaded && !noConnecteur ? (
- <div className="lack-of-data-challenge">
- <div className="lack-of-data-content">
- <div className="warning-white">
- <StyledIcon
- icon={warningWhite}
- size={36}
- className="warning-icon"
- />
- <span>
- {t('CHALLENGE.LACK_OF_DATA')}{' '}
- {DateTime.fromObject(
- lackOfDataFluidtype.periode.startDate.c
- ).toLocaleString(DateTime.DATE_FULL)}{' '}
- {t('CHALLENGE.LACK_OF_DATA_1')}{' '}
- {DateTime.fromObject(
- lackOfDataFluidtype.periode.endDate.c
- ).toLocaleString(DateTime.DATE_FULL)}
- {t('CHALLENGE.LACK_OF_DATA_2')}
- </span>
- </div>
- {lackOfDataFluidtype.fluidType.map(
- (idFLuid: number) => {
- return (
- <div key={idFLuid} className="fluid-enum">
- {' '}
- - {t(
- 'FLUID.' + FluidType[idFLuid] + '.NAME'
- )}{' '}
- </div>
- )
- }
- )}
- <span></span>
- </div>
- </div>
- ) : null}
- </div>
- <div className="cp-valid">
- <div className="cp-left-button">
- <StyledButtonValid
- color="secondary"
- onClick={() => history.goBack()}
- >
- {t('CHALLENGE.NOT_NOW')}
- </StyledButtonValid>
- </div>
- <div className="cp-right-button">
- <StyledButtonValid
- disabled={lackOfDataForChallenge && isLoaded}
- color="primary"
- onClick={handleStartClick}
- >
- {t('CHALLENGE.START')}
- {renderRedirect()}
- </StyledButtonValid>
- </div>
- </div>
- </div>
- </div>
- </div>
- </>
- )}
- </Content>
- </React.Fragment>
- )
-}
-
-export default AvailableChallengeDetailsView
diff --git a/src/components/Challenge/ChallengeCardLink.tsx b/src/components/Challenge/ChallengeCardLink.tsx
deleted file mode 100644
index d023dd3c4806e42f30c20d4b7d21d0b44799b45c..0000000000000000000000000000000000000000
--- a/src/components/Challenge/ChallengeCardLink.tsx
+++ /dev/null
@@ -1,26 +0,0 @@
-import React from 'react'
-import { useI18n } from 'cozy-ui/transpiled/react/I18n'
-import { useRecoilValue } from 'recoil'
-import { currentChallengeState } from 'atoms/challenge.state'
-import ChallengeCardLinkItem from 'components/Challenge/ChallengeCardLinkItem'
-
-const ChallengeCardLink: React.FC = () => {
- const { t } = useI18n()
- const currentChallenge = useRecoilValue(currentChallengeState)
- return (
- <>
- <div className="ccc-root">
- {currentChallenge && currentChallenge.challengeType && (
- <div className="ccc-content">
- <div className="ccc-header text-14-normal-uppercase">
- {t('COMMON.CHALLENGE_CARD_LABEL')}
- </div>
- <ChallengeCardLinkItem userChallenge={currentChallenge} />
- </div>
- )}
- </div>
- </>
- )
-}
-
-export default ChallengeCardLink
diff --git a/src/components/Challenge/ChallengeCardLinkItem.tsx b/src/components/Challenge/ChallengeCardLinkItem.tsx
deleted file mode 100644
index 650ab10de2098122e4d2b1aecc2f94e210d17ca9..0000000000000000000000000000000000000000
--- a/src/components/Challenge/ChallengeCardLinkItem.tsx
+++ /dev/null
@@ -1,82 +0,0 @@
-import React from 'react'
-import { NavLink } from 'react-router-dom'
-import { useRecoilValue } from 'recoil'
-
-import { TypeChallenge } from 'enum/challenge.enum'
-import { challengeNotificationState } from 'atoms/notification.state'
-import { UserChallenge } from 'models'
-
-import StyledChallengeCard from 'components/CommonKit/Card/StyledChallengeCard'
-import StyledIcon from 'components/CommonKit/Icon/StyledIcon'
-import ChallengePile from 'components/Challenge/ChallengePile'
-import ChallengeViewingDate from 'components/Challenge/ChallengeViewingDate'
-import ChallengeTimeline from 'components/Challenge/ChallengeTimeline'
-import BlackArrowIcon from 'assets/icons/ico/black-arrow.svg'
-
-interface ChallengeCardLinkItemProps {
- userChallenge: UserChallenge
-}
-
-const ChallengeCardLinkItem: React.FC<ChallengeCardLinkItemProps> = ({
- userChallenge,
-}: ChallengeCardLinkItemProps) => {
- const challengeNotification = useRecoilValue(challengeNotificationState)
- const challengesPath = 'challenges'
- const challengeDetailPath = {
- pathname: `challenges/ongoing`,
- state: userChallenge,
- }
- return (
- <NavLink
- className="cc-link"
- to={challengeNotification ? challengesPath : challengeDetailPath}
- >
- <div>
- {userChallenge.challengeType &&
- userChallenge.challengeType.type === TypeChallenge.CHALLENGE ? (
- <StyledChallengeCard displayBorder={true}>
- <div className="cc">
- <div className="cc-content-left">
- <div className="cc-content-title cc-content-title-padding text-18-normal">
- {userChallenge.challengeType.title}
- </div>
- <div className="cc-content-progress">
- <ChallengePile challenge={userChallenge} small={true} />
- </div>
- <div className="cc-content-timeline">
- <ChallengeTimeline challenge={userChallenge} />
- </div>
- <div className="cc-content-visu text-15-normal">
- <ChallengeViewingDate challenge={userChallenge} />
- </div>
- </div>
- <div className="cc-content-right">
- <StyledIcon icon={BlackArrowIcon} size={18} />
- </div>
- </div>
- </StyledChallengeCard>
- ) : (
- <StyledChallengeCard displayBorder={challengeNotification}>
- <div className="cc">
- <div className="cc-content-left">
- <div className="cc-content-title text-18-normal">
- {userChallenge.challengeType
- ? userChallenge.challengeType.title
- : null}
- </div>
- </div>
- <div className="cc-content-right">
- {challengeNotification && (
- <div className="cc-notification text-16-bold">1</div>
- )}
- <StyledIcon icon={BlackArrowIcon} size={18} />
- </div>
- </div>
- </StyledChallengeCard>
- )}
- </div>
- </NavLink>
- )
-}
-
-export default ChallengeCardLinkItem
diff --git a/src/components/Challenge/ChallengeList.tsx b/src/components/Challenge/ChallengeList.tsx
deleted file mode 100644
index 03c0faf0832ba835b84695125058f3f77e620530..0000000000000000000000000000000000000000
--- a/src/components/Challenge/ChallengeList.tsx
+++ /dev/null
@@ -1,216 +0,0 @@
-import React, { useState, useEffect } from 'react'
-import { useClient } from 'cozy-client'
-import { useRecoilState, useRecoilValue, useSetRecoilState } from 'recoil'
-
-import { ChallengeState } from 'enum/challenge.enum'
-import { ScreenType } from 'enum/screen.enum'
-import { fluidTypeState } from 'atoms/fluidState.state'
-import { challengeNotificationState } from 'atoms/notification.state'
-import { screenTypeState } from 'atoms/screenType.state'
-import { currentChallengeState } from 'atoms/challenge.state'
-import { userProfileState } from 'atoms/userProfile.state'
-import { ChallengeType, UserChallenge } from 'models'
-import ChallengeService from 'services/challenge.service'
-import UserProfileService from 'services/userProfile.service'
-
-import StyledChallengeSpinner from 'components/CommonKit/Spinner/StyledChallengeSpinner'
-import ChallengeListItem from 'components/Challenge/ChallengeListItem'
-import ChallengeModal from 'components/Challenge/ChallengeModal'
-
-const ChallengeList: React.FC = () => {
- const client = useClient()
- const screenType = useRecoilValue(screenTypeState)
- const fluidTypes = useRecoilValue(fluidTypeState)
- const [userProfile, setUserProfile] = useRecoilState(userProfileState)
- const [challengeNotification, setChallengeNotification] = useRecoilState(
- challengeNotificationState
- )
- const setCurrentChallenge = useSetRecoilState(currentChallengeState)
-
- const challengeService = new ChallengeService(client)
- const userProfileService = new UserProfileService(client)
- const [
- ongoingChallenge,
- setOngoingChallenge,
- ] = useState<UserChallenge | null>(null)
- const [
- ongoingChallengeModal,
- setOngoingChallengeModal,
- ] = useState<UserChallenge | null>(null)
- const [challengesType, setChallengesType] = useState<ChallengeType[] | null>(
- null
- )
- const [userChallenges, setUserChallenges] = useState<UserChallenge[] | null>(
- null
- )
- const [openChallengeModal, setOpenChallengeModal] = useState(false)
- const [scroll, setScroll] = useState(0)
- const [paddingBottom, setPaddingBottom] = useState(0)
-
- const handleCloseClick = () => {
- setOngoingChallenge(null)
- setOpenChallengeModal(false)
- setOngoingChallengeModal(null)
- }
-
- const setRightChallengeInTheMiddle = (
- _challengesType: ChallengeType[],
- _userChallenges: UserChallenge[]
- ) => {
- const header = screenType === ScreenType.MOBILE ? 96 : 174
- const bottomNav = screenType === ScreenType.MOBILE ? 60 : 0
- const challengeCard = screenType === ScreenType.MOBILE ? 100 : 120
- const _paddingBottom =
- (window.innerHeight - header - bottomNav) / 2 -
- _userChallenges.length * challengeCard
- const canFitInHalfScreen =
- window.innerHeight / 2 - header >
- (_challengesType.length - 1) * challengeCard
- if (_userChallenges[0].state === 0) {
- setPaddingBottom(_paddingBottom + bottomNav)
- if (canFitInHalfScreen) {
- setScroll(0)
- } else {
- setScroll(
- (challengeCard / 2) *
- _challengesType.length *
- (1 + challengeCard / window.innerHeight)
- )
- }
- } else {
- setPaddingBottom(_paddingBottom - challengeCard + bottomNav)
- if (canFitInHalfScreen) {
- setScroll(0)
- } else {
- setScroll(
- (challengeCard / 2) *
- (_challengesType.length - 1) *
- (1 + challengeCard / window.innerHeight)
- )
- }
- }
- }
-
- useEffect(() => {
- let subscribed = true
- async function loadAvailableChallenges() {
- const dataAllCT = await challengeService.getAvailableChallenges(
- fluidTypes
- )
- const dataAllUC = await challengeService.getAllUserChallenges()
- if (subscribed && dataAllCT && dataAllUC) {
- const ongoingChallengeTmp = dataAllUC.filter(
- challenge => challenge.state === ChallengeState.ONGOING
- )[0]
- setRightChallengeInTheMiddle(dataAllCT, dataAllUC)
- setChallengesType(dataAllCT)
- setUserChallenges(dataAllUC)
- setOngoingChallenge(ongoingChallengeTmp)
- setOngoingChallengeModal(ongoingChallengeTmp)
- if (challengeNotification) {
- setOpenChallengeModal(true)
- await challengeService.endChallenge(ongoingChallengeTmp, fluidTypes)
- await userProfileService.getUserProfile().then(updatedUserProfile => {
- updatedUserProfile && setUserProfile(updatedUserProfile)
- })
- setCurrentChallenge(null)
- setChallengeNotification(false)
- setOngoingChallenge(null)
- }
- }
- }
- loadAvailableChallenges()
- return () => {
- subscribed = false
- }
- }, [])
-
- useEffect(() => {
- let subscribed = true
- async function loadNewChallengesType() {
- const dataAllCT = await challengeService.getAvailableChallenges(
- fluidTypes
- )
- const dataAllUC = await challengeService.getAllUserChallenges()
- if (subscribed && dataAllCT && dataAllUC) {
- setChallengesType(dataAllCT)
- setUserChallenges(dataAllUC)
- setRightChallengeInTheMiddle(dataAllCT, dataAllUC)
- }
- }
- loadNewChallengesType()
- return () => {
- subscribed = false
- }
- }, [ongoingChallenge])
-
- window.scrollTo({
- top: scroll,
- behavior: 'smooth',
- })
-
- return (
- <>
- {!challengesType ? (
- <div className="content-view-loading">
- <StyledChallengeSpinner size="5em" />
- </div>
- ) : (
- <div className="loc-root">
- <div className="loc-content">
- <div className="timeline-line"></div>
- <div
- className="list-of-challenge-cards"
- style={{ paddingBottom: paddingBottom }}
- >
- {challengesType.map((challenge, index) =>
- index === challengesType.length - 1 &&
- !ongoingChallenge &&
- userProfile.level ===
- challengesType[challengesType.length - 1].level ? (
- <ChallengeListItem
- key={index}
- challenge={challenge}
- challengeState="available"
- />
- ) : ongoingChallenge &&
- challengesType.length - 1 === index ? null : (
- <ChallengeListItem
- key={index}
- challenge={challenge}
- challengeState="locked"
- />
- )
- )}
- {userChallenges &&
- userChallenges.map((challenge, index) => (
- <ChallengeListItem
- key={index}
- challenge={
- challenge.challengeType
- ? challenge.challengeType
- : undefined
- }
- userChallenge={challenge}
- challengeState={
- challenge.state === 0 ? 'ongoing' : 'finished'
- }
- />
- ))}
- </div>
- </div>
- </div>
- )}
- {openChallengeModal && ongoingChallengeModal && (
- <ChallengeModal
- opened={openChallengeModal}
- challenge={ongoingChallengeModal}
- handleCloseClick={handleCloseClick}
- badgeStatus={ongoingChallengeModal && ongoingChallengeModal.badge}
- />
- )}
- </>
- )
-}
-
-export default ChallengeList
diff --git a/src/components/Challenge/ChallengeListItem.tsx b/src/components/Challenge/ChallengeListItem.tsx
deleted file mode 100644
index adc5ef5332c442e36db4925cfd0cae26e2de1417..0000000000000000000000000000000000000000
--- a/src/components/Challenge/ChallengeListItem.tsx
+++ /dev/null
@@ -1,125 +0,0 @@
-import React, { useState, useEffect } from 'react'
-import { useI18n } from 'cozy-ui/transpiled/react/I18n'
-import { NavLink } from 'react-router-dom'
-
-import { ChallengeType, Ecogesture, UserChallenge } from 'models'
-
-import StyledIcon from 'components/CommonKit/Icon/StyledIcon'
-import ChevronGrey from 'assets/icons/ico/chevron-right-grey.svg'
-import ChevronBlue from 'assets/icons/ico/chevron-right-blue.svg'
-import ChevronDarkBlue from 'assets/icons/ico/chevron-right-darkblue.svg'
-import LockedChallengeIcon from 'assets/png/badges/locked.png'
-import AvailableChallengeIcon from 'assets/png/badges/available.png'
-import OngoingChallengeIcon from 'assets/png/badges/ongoing.png'
-import DefaultChallengeIcon from 'assets/png/badges/default.png'
-
-interface ChallengeListItemProps {
- challenge?: ChallengeType
- userChallenge?: UserChallenge
- handleClick?: (challenge: ChallengeType) => void
- challengeState?: string
- ecogestures?: Ecogesture[]
-}
-
-const ChallengeListItem: React.FC<ChallengeListItemProps> = ({
- challenge,
- userChallenge,
- challengeState,
-}: ChallengeListItemProps) => {
- const { t } = useI18n()
- const [badgeIcon, setBadgeIcon] = useState<string | undefined>()
-
- async function importRightBadge(id: string, badgeStatus: number) {
- if (badgeStatus !== -1) {
- // Les png doivent être au format idchallenge-badgestate.png
- const importedBadge =
- id === 'CHA00000001'
- ? await import(
- /* webpackMode: "eager" */ `assets/png/badges/${id}-1.png`
- )
- : await import(
- /* webpackMode: "eager" */ `assets/png/badges/${id}-${badgeStatus}.png`
- )
- setBadgeIcon(importedBadge.default)
- }
- }
-
- const defineBadge = () => {
- return challengeState === 'locked'
- ? LockedChallengeIcon
- : challengeState === 'available'
- ? AvailableChallengeIcon
- : challengeState === 'ongoing'
- ? OngoingChallengeIcon
- : challengeState === 'finished'
- ? badgeIcon
- : DefaultChallengeIcon
- }
-
- useEffect(() => {
- if (challenge && userChallenge) {
- importRightBadge(
- challenge.id,
- userChallenge.badge ? userChallenge.badge : 0
- )
- }
- }, [])
-
- return (
- <NavLink
- className="cli-link"
- to={{
- pathname: `challenges/${challengeState}`,
- state: userChallenge ? userChallenge : challenge,
- }}
- >
- <div className={`cli cli-${challengeState}`}>
- <div className="cli-left">
- <div className="cli-content">
- <img
- className="cli-content-icon"
- src={defineBadge() ? defineBadge() : DefaultChallengeIcon}
- ></img>
- <div className={`cli-content-title`}>
- {challengeState === 'available' && (
- <div className={`subtitle-${challengeState} text-16-normal`}>
- {t('CHALLENGE.NEW_CHALLENGE')}
- </div>
- )}
- {challengeState === 'ongoing' && (
- <div className={`subtitle-${challengeState} text-16-normal`}>
- {t('CHALLENGE.ONGOING_CHALLENGE')}
- </div>
- )}
- {challengeState === 'finished' && (
- <div className={`subtitle-${challengeState} text-16-normal`}>
- {userChallenge
- ? userChallenge.endingDate
- .setLocale('fr-FR')
- .toLocaleString()
- : t('CHALLENGE.ENDINGDATE_UNDEFINED')}
- </div>
- )}
- <div className={`title-${challengeState} text-18-bold`}>
- {challenge && challenge.title
- ? challenge.title
- : t('CHALLENGE.NO_CHALLENGE')}
- </div>
- </div>
- </div>
- </div>
- <div className={`cli-right cli-right-${challengeState}`}>
- {challengeState === 'available' ? (
- <StyledIcon icon={ChevronDarkBlue} size={18} />
- ) : challengeState === 'ongoing' ? (
- <StyledIcon icon={ChevronBlue} size={18} />
- ) : (
- <StyledIcon icon={ChevronGrey} size={18} />
- )}
- </div>
- </div>
- </NavLink>
- )
-}
-
-export default ChallengeListItem
diff --git a/src/components/Challenge/ChallengeModal.tsx b/src/components/Challenge/ChallengeModal.tsx
deleted file mode 100644
index 20e4149a62032a3964220a865c57f5ab536c9c11..0000000000000000000000000000000000000000
--- a/src/components/Challenge/ChallengeModal.tsx
+++ /dev/null
@@ -1,165 +0,0 @@
-import React, { useState } from 'react'
-import { useI18n } from 'cozy-ui/transpiled/react/I18n'
-import { useRecoilValue } from 'recoil'
-
-import { ScreenType } from 'enum/screen.enum'
-import { screenTypeState } from 'atoms/screenType.state'
-import { UserChallenge } from 'models'
-import { formatNumberValues } from 'utils/utils'
-
-import Modal from 'components/CommonKit/Modal/Modal'
-import StyledSpinner from 'components/CommonKit/Spinner/StyledSpinner'
-import StarIcon from 'assets/icons/visu/challenge/star.svg'
-import StyledButtonValid from 'components/CommonKit/Button/StyledButtonValid'
-import StyledIcon from 'components/CommonKit/Icon/StyledIcon'
-
-interface ChallengeModalProps {
- opened: boolean
- challenge: UserChallenge
- handleCloseClick: () => void
- badgeStatus: number | null
-}
-
-const ChallengeModal: React.FC<ChallengeModalProps> = ({
- opened,
- challenge,
- handleCloseClick,
- badgeStatus,
-}: ChallengeModalProps) => {
- const { t } = useI18n()
- const screenType = useRecoilValue(screenTypeState)
- const [badgeIcon, setBadgeIcon] = useState<string | null>(null)
-
- async function importRightBadge(id: string, _badgeStatus: number) {
- if (badgeStatus !== -1) {
- // Les png doivent être au format idchallenge-badgestate.png
- const importedBadge =
- id === 'CHA00000001'
- ? await import(
- /* webpackMode: "eager" */ `assets/png/badges/${id}-1.png`
- )
- : await import(
- /* webpackMode: "eager" */ `assets/png/badges/${id}-${_badgeStatus}.png`
- )
- setBadgeIcon(importedBadge.default)
- }
- }
-
- const showTheRightBadge = (_badgeStatus: number | null) => {
- const result =
- challenge &&
- formatNumberValues(
- Math.abs(challenge.maxEnergy - challenge.currentEnergy)
- )
- const challengeId = challenge.challengeType
- ? challenge.challengeType.id
- : ''
- const badge = challenge.badge ? challenge.badge : 0
- importRightBadge(challengeId, badge)
- if (badgeIcon) {
- if (_badgeStatus === 1) {
- return (
- <>
- <div className="cm-title win text-24-bold ">
- {' '}
- {t('CHALLENGE.CONGRATULATION')}
- </div>
- <div className="cm-result text-18-bold">
- {challengeId !== 'CHA00000001' ? (
- <>
- <div>{t('CHALLENGE.RESULT_POSITIF')}</div>
- <div className="cm-result-positif text-18-normal">{`${result} €`}</div>
- </>
- ) : null}
- </div>
- <div
- className={
- challengeId !== 'CHA00000001'
- ? 'cm-win-badge-star'
- : 'cm-win-badge-star --ecolyo-royal'
- }
- >
- <img
- className="cm-win-badge"
- src={badgeIcon}
- width={screenType === ScreenType.MOBILE ? 160 : 180}
- ></img>
- <StyledIcon
- className="cm-win-star"
- icon={StarIcon}
- size={ScreenType.MOBILE ? 260 : 320}
- />
- </div>
- <div className="cm-txt">
- {' '}
- {challengeId === 'CHA00000001' ? (
- <>
- <div className="text-18-normal">
- {t('CHALLENGE.WIN_TEXT_ECOLYO')}
- </div>
- <div className="cm-text-new-available text-18-bold">
- {t('CHALLENGE.WIN_TEXT_ECOLYO_NEW_AVAILABLE')}
- </div>
- </>
- ) : (
- <div className="text-18-bold">
- {t('CHALLENGE.WIN_TEXT')}
- <div>{`"${challenge &&
- challenge.challengeType &&
- challenge.challengeType.title}"`}</div>
- </div>
- )}
- </div>
- <StyledButtonValid onClick={handleCloseClick}>
- {t('CHALLENGE.OK')}
- </StyledButtonValid>
- </>
- )
- } else {
- return (
- <>
- <div className="cm-title defeat text-24-bold ">
- {t('CHALLENGE.DEFEAT')}
- </div>
- <div className="cm-result text-18-bold">
- <div>{t('CHALLENGE.DEFEAT_RESULT')}</div>
- <div>
- {t('CHALLENGE.DEFEAT_RESULT2')}
- <span className="cm-result-negatif text-18-normal">{`${result} €`}</span>
- </div>
- </div>
- <img
- className="cm-badge"
- src={badgeIcon}
- width={screenType === ScreenType.MOBILE ? 160 : 180}
- ></img>
- <div className="cm-txt text-18-bold ">
- {' '}
- {t('CHALLENGE.CONSOLATION')}
- {`"${challenge &&
- challenge.challengeType &&
- challenge.challengeType.title}"`}
- {t('CHALLENGE.CONSOLATION2')}
- </div>
- <div className="cm-button-valid">
- <StyledButtonValid onClick={handleCloseClick}>
- {t('CHALLENGE.OK')}
- </StyledButtonValid>
- </div>
- </>
- )
- }
- }
- }
- return (
- <Modal open={opened} handleCloseClick={handleCloseClick} border>
- {!challenge ? (
- <StyledSpinner />
- ) : (
- <div className="cm-content">{showTheRightBadge(badgeStatus)}</div>
- )}
- </Modal>
- )
-}
-
-export default ChallengeModal
diff --git a/src/components/Challenge/ChallengePile.tsx b/src/components/Challenge/ChallengePile.tsx
deleted file mode 100644
index b29a1b3185123a435135d48215faa31ae64c2215..0000000000000000000000000000000000000000
--- a/src/components/Challenge/ChallengePile.tsx
+++ /dev/null
@@ -1,79 +0,0 @@
-import React, { useState, useEffect } from 'react'
-import { useI18n } from 'cozy-ui/transpiled/react/I18n'
-
-import { UserChallenge } from 'models'
-import { formatNumberValues } from 'utils/utils'
-
-import pile from 'assets/icons/visu/challenge/pile.svg'
-import StyledIcon from 'components/CommonKit/Icon/StyledIcon'
-
-interface ChallengePileProps {
- challenge: UserChallenge
- small?: boolean
-}
-
-const ChallengePile: React.FC<ChallengePileProps> = ({
- challenge,
- small = false,
-}: ChallengePileProps) => {
- const { t } = useI18n()
- const [pilePercent, setPilePercent] = useState<number>(0)
- const sizePile = small ? 100 : 150
- const textFont = small ? 'text-17-bold' : 'text-20-bold'
-
- const getPileSectionPercent = (percent: number) => {
- if (percent <= 100) {
- return Math.floor(percent / 5) * 5
- }
- return 100
- }
-
- useEffect(() => {
- if (challenge) {
- const percent =
- challenge.maxEnergy > 0
- ? (challenge.currentEnergy * 100) / challenge.maxEnergy
- : 0
- setPilePercent(getPileSectionPercent(percent))
- }
- }, [])
-
- return (
- <React.Fragment>
- <div className={`pile-energy-follow ${small ? '--home' : null}`}>
- <div className="pile-section">
- <div
- className="filter-pile"
- style={{
- width: `${pilePercent}%`,
- height: `${small ? '30px' : '46px'}`,
- }}
- ></div>
- <StyledIcon className="pile-icon" icon={pile} size={sizePile} />
- </div>
- {challenge && challenge.maxEnergy > 0 ? (
- <div className={`values-section ${textFont}`}>
- <span>
- {challenge.currentEnergy && challenge.currentEnergy !== -1
- ? formatNumberValues(
- challenge.maxEnergy - challenge.currentEnergy
- )
- : formatNumberValues(challenge.maxEnergy)}{' '}
- €
- </span>
- <span className="max-energy">
- {' '}
- / {formatNumberValues(challenge.maxEnergy)} €
- </span>
- </div>
- ) : (
- <div className={`no-values-section text-18-bold`}>
- {t('CHALLENGE.RESULT_NOT_AVAILABLE')}
- </div>
- )}
- </div>
- </React.Fragment>
- )
-}
-
-export default ChallengePile
diff --git a/src/components/Challenge/ChallengeTimeline.tsx b/src/components/Challenge/ChallengeTimeline.tsx
deleted file mode 100644
index 5f81faf3b3905f4f01a26e23ff55493480805e99..0000000000000000000000000000000000000000
--- a/src/components/Challenge/ChallengeTimeline.tsx
+++ /dev/null
@@ -1,167 +0,0 @@
-import React from 'react'
-import { DateTime, Interval } from 'luxon'
-
-import { UserChallenge } from 'models'
-import { getLagDays } from 'utils/date'
-
-interface ChallengeTimelineViewProps {
- challenge: UserChallenge
-}
-
-const ChallengeTimeline: React.FC<ChallengeTimelineViewProps> = ({
- challenge,
-}: ChallengeTimelineViewProps) => {
- const viewingDate = () => {
- if (challenge && challenge.challengeType) {
- const startingDate = challenge.startingDate
- return startingDate.plus({
- days: getLagDays(challenge.fluidTypes),
- })
- } else {
- return DateTime.local()
- }
- }
-
- const getListOfDays = () => {
- if (challenge && challenge.challengeType) {
- const startingDate = DateTime.fromISO(challenge.startingDate.toString())
- const listOfChallengeDays = []
- let i = 0
- if (challenge.challengeType.duration.days === 7) {
- while (challenge.challengeType.duration.days > i) {
- listOfChallengeDays.push({
- letter: startingDate
- .plus({ days: i })
- .weekdayShort[0].toUpperCase(),
- date: startingDate.plus({ days: i }).day,
- })
- i++
- }
- } else {
- while (challenge.challengeType.duration.days >= i) {
- listOfChallengeDays.push({
- letter: '',
- date: startingDate.plus({ days: i }).toFormat('dd/MM'),
- })
- i += 7
- }
- }
- return listOfChallengeDays
- } else {
- return []
- }
- }
-
- const getListOfWeeks = () => {
- if (challenge && challenge.challengeType) {
- const startingDate = DateTime.fromISO(challenge.startingDate.toString())
- const listOfChallengeDays = []
- let i = 0
- while (challenge.challengeType.duration.days >= i) {
- listOfChallengeDays.push({
- letter: '',
- date: startingDate.plus({ days: i }).toFormat('dd/MM'),
- })
- i += 7
- }
- return listOfChallengeDays
- } else {
- return []
- }
- }
-
- const getListOfPastDays = () => {
- if (Interval.fromDateTimes(viewingDate(), DateTime.local()).isValid) {
- if (challenge && challenge.challengeType) {
- return Interval.fromDateTimes(viewingDate(), DateTime.local()).count(
- 'days'
- )
- } else {
- return 0
- }
- } else {
- if (challenge) {
- return -Interval.fromDateTimes(DateTime.local(), viewingDate()).count(
- 'days'
- )
- } else {
- return 0
- }
- }
- }
-
- const generateMonthTimelinePart = (
- index: number,
- dayCount: number,
- className: string
- ) => {
- return (
- <div
- className={`${className} ${
- (index === 0 && dayCount > 0) ||
- (index === getListOfWeeks().length - 1 && dayCount < 0)
- ? 'none'
- : index * 7 < getListOfPastDays() + dayCount
- ? 'past'
- : 'futur'
- }`}
- ></div>
- )
- }
-
- const generateWeekTimelinePart = (index: number, className: string) => {
- return (
- <div
- className={`${className} ${
- index < getListOfPastDays() ? 'past' : 'futur'
- }`}
- ></div>
- )
- }
-
- const monthChallenge = () => {
- return getListOfWeeks().map((day, index) => (
- <div key={index} className="day-solo">
- <div className="day-line-label">
- {generateMonthTimelinePart(index, 3, 'date-dash')}
- {generateMonthTimelinePart(index, 2, 'date-dash')}
- {generateMonthTimelinePart(index, 1, 'date-dash')}
- {generateMonthTimelinePart(index, 0, 'date-label')}
- {generateMonthTimelinePart(index, -1, 'date-dash')}
- {generateMonthTimelinePart(index, -2, 'date-dash')}
- {generateMonthTimelinePart(index, -3, 'date-dash')}
- </div>
- <div className="day-letter">{day.letter}</div>
- <div className="day-date">{day.date}</div>
- </div>
- ))
- }
-
- const weekChallenge = () => {
- return getListOfDays().map((day, index) => (
- <div key={index} className="day-solo">
- <div className="day-line-label">
- {generateWeekTimelinePart(index, 'date-dash')}
- {generateWeekTimelinePart(index, 'date-label')}
- {generateWeekTimelinePart(index + 1, 'date-dash')}
- </div>
- <div className="day-letter">{day.letter}</div>
- <div className="day-date">{day.date}</div>
- </div>
- ))
- }
-
- return (
- <React.Fragment>
- <div className="list-of-days-duration">
- {challenge &&
- challenge.challengeType &&
- challenge.challengeType.duration.days === 7
- ? weekChallenge()
- : monthChallenge()}
- </div>
- </React.Fragment>
- )
-}
-
-export default ChallengeTimeline
diff --git a/src/components/Challenge/ChallengeView.tsx b/src/components/Challenge/ChallengeView.tsx
deleted file mode 100644
index 9be9e28ea651c704a1231e683a84c6d50e70d30c..0000000000000000000000000000000000000000
--- a/src/components/Challenge/ChallengeView.tsx
+++ /dev/null
@@ -1,28 +0,0 @@
-import React, { useState } from 'react'
-import CozyBar from 'components/Header/CozyBar'
-import Header from 'components/Header/Header'
-import Content from 'components/Content/Content'
-import ChallengesList from 'components/Challenge/ChallengeList'
-
-const ChallengeView: React.FC = () => {
- const [headerHeight, setHeaderHeight] = useState<number>(0)
-
- const defineHeaderHeight = (height: number) => {
- setHeaderHeight(height)
- }
-
- return (
- <React.Fragment>
- <CozyBar titleKey={'COMMON.APP_CHALLENGE_TITLE'} />
- <Header
- setHeaderHeight={defineHeaderHeight}
- desktopTitleKey={'COMMON.APP_CHALLENGE_TITLE'}
- ></Header>
- <Content height={headerHeight} background="var(--darkLight2)">
- <ChallengesList />
- </Content>
- </React.Fragment>
- )
-}
-
-export default ChallengeView
diff --git a/src/components/Challenge/ChallengeViewingDate.tsx b/src/components/Challenge/ChallengeViewingDate.tsx
deleted file mode 100644
index 4c96a94f971fca8fa03fbb4224277a1b78844663..0000000000000000000000000000000000000000
--- a/src/components/Challenge/ChallengeViewingDate.tsx
+++ /dev/null
@@ -1,61 +0,0 @@
-import React, { useState, useEffect } from 'react'
-import { useI18n } from 'cozy-ui/transpiled/react/I18n'
-import { DateTime } from 'luxon'
-
-import { UserChallenge } from 'models'
-import { getLagDays } from 'utils/date'
-
-interface ChallengeViewingDateProps {
- challenge: UserChallenge
-}
-
-const ChallengeViewingDate: React.FC<ChallengeViewingDateProps> = ({
- challenge,
-}: ChallengeViewingDateProps) => {
- const { t } = useI18n()
- const [firstDateWithData, setFirstDateWithData] = useState<DateTime | null>(
- null
- )
- const [lastDateWithData, setLastDateWithData] = useState<DateTime | null>(
- null
- )
- const diffDays =
- firstDateWithData && firstDateWithData.diffNow(['days']).toObject().days
- const diffDaysCeil = Math.ceil(diffDays || 0)
-
- useEffect(() => {
- if (challenge) {
- const lag = getLagDays(challenge.fluidTypes)
- setFirstDateWithData(
- challenge.startingDate.plus({
- days: lag - 1,
- })
- )
- setLastDateWithData(
- challenge.endingDate.plus({
- days: lag - 1,
- })
- )
- }
- }, [])
- /* eslint-disable @typescript-eslint/camelcase */
- return (
- <React.Fragment>
- {firstDateWithData && firstDateWithData > DateTime.local() ? (
- <div className="view-start-date">
- {t('CHALLENGE.VIEW_START', {
- diffDaysCeil,
- smart_count: diffDaysCeil,
- })}
- </div>
- ) : (
- <div className="view-start-date">
- {t('CHALLENGE.VIEW_RESULT')}
- <span>{lastDateWithData && lastDateWithData.toLocaleString()}</span>
- </div>
- )}
- </React.Fragment>
- )
-}
-
-export default ChallengeViewingDate
diff --git a/src/components/Challenge/FinishedChallengeDetailsView.tsx b/src/components/Challenge/FinishedChallengeDetailsView.tsx
deleted file mode 100644
index 12208658fa355fb390d05c766f3dda26215ce15d..0000000000000000000000000000000000000000
--- a/src/components/Challenge/FinishedChallengeDetailsView.tsx
+++ /dev/null
@@ -1,183 +0,0 @@
-import React, { useState, useEffect } from 'react'
-import { useI18n } from 'cozy-ui/transpiled/react/I18n'
-import { Redirect } from 'react-router-dom'
-import { useRecoilValue } from 'recoil'
-import { Location } from 'history'
-
-import { TypeChallenge, BadgeState } from 'enum/challenge.enum'
-import { ScreenType } from 'enum/screen.enum'
-import { UserChallenge } from 'models'
-import { screenTypeState } from 'atoms/screenType.state'
-import { formatNumberValues } from 'utils/utils'
-
-import CozyBar from 'components/Header/CozyBar'
-import Header from 'components/Header/Header'
-import Content from 'components/Content/Content'
-import StyledSpinner from 'components/CommonKit/Spinner/StyledSpinner'
-import StarIcon from 'assets/png/challenge/star.png'
-import EcogestureModal from 'components/Ecogesture/EcogestureModal'
-import EcogestureCard from 'components/Ecogesture/EcogestureCard'
-
-interface FinishedChallengeDetailsViewProps {
- location: Location<UserChallenge>
-}
-
-const FinishedChallengeDetailsView: React.FC<FinishedChallengeDetailsViewProps> = ({
- location,
-}: FinishedChallengeDetailsViewProps) => {
- const { t } = useI18n()
- const userChallengeState = location.state
- const screenType = useRecoilValue(screenTypeState)
- const [challengeEcogesture, setChallengeEcogesture] = useState<number>(0)
- const [openEcogestureModal, setOpenEcogestureModal] = useState(false)
- const [challenge, setChallenge] = useState<UserChallenge | null>(null)
- const [headerHeight, setHeaderHeight] = useState<number>(0)
- const [badgeIcon, setBadgeIcon] = useState<string | undefined>()
-
- async function importRightBadge(id: string, badgeStatus: number) {
- if (badgeStatus !== -1) {
- // Les png doivent être au format idchallenge-badgestate.png
- const importedBadge =
- id === 'CHA00000001'
- ? await import(
- /* webpackMode: "eager" */ `assets/png/badges/${id}-1.png`
- )
- : await import(
- /* webpackMode: "eager" */ `assets/png/badges/${id}-${badgeStatus}.png`
- )
- setBadgeIcon(importedBadge.default)
- }
- }
-
- const defineHeaderHeight = (height: number) => {
- setHeaderHeight(height)
- }
-
- const handleClick = (index: number) => {
- setChallengeEcogesture(index)
- setOpenEcogestureModal(true)
- }
-
- const handleCloseClick = () => {
- setOpenEcogestureModal(false)
- }
-
- useEffect(() => {
- if (userChallengeState) {
- setChallenge(userChallengeState)
- if (
- userChallengeState.challengeType &&
- userChallengeState.badge != null
- ) {
- importRightBadge(
- userChallengeState.challengeType.id,
- userChallengeState.badge
- )
- }
- }
- }, [])
-
- const result =
- challenge &&
- formatNumberValues(Math.abs(challenge.maxEnergy - challenge.currentEnergy))
-
- return (
- <React.Fragment>
- <CozyBar
- titleKey={'COMMON.APP_FINISHED_CHALLENGE_TITLE'}
- displayBackArrow={true}
- />
- <Header
- setHeaderHeight={defineHeaderHeight}
- desktopTitleKey={'COMMON.APP_FINISHED_CHALLENGE_TITLE'}
- displayBackArrow={true}
- ></Header>
- {!userChallengeState ? <Redirect to="/challenges" /> : null}
- <Content height={headerHeight} background="var(--darkLight2)">
- {!challenge ? (
- <StyledSpinner />
- ) : (
- <>
- <div className="cp-root">
- <div className="cp-content">
- <div className="cp-info">
- <div className="cp-date text-16-normal">
- {challenge.endingDate.setLocale('fr-FR').toLocaleString()}
- </div>
- <div className="cp-title text-22-bold">
- {challenge.challengeType && challenge.challengeType.title}
- </div>
- {challenge.challengeType &&
- challenge.challengeType.type === TypeChallenge.CHALLENGE ? (
- challenge.badge === BadgeState.SUCCESS ? (
- <div className="cp-result text-18-bold">
- <div>{t('CHALLENGE.RESULT_POSITIF')}</div>
- <div className="cp-result-positif text-18-normal">{`${result} €`}</div>
- </div>
- ) : (
- <div className="cp-result text-18-bold">
- <div>{t('CHALLENGE.RESULT_NEGATIF')}</div>
- <div className="cp-result-negatif text-18-normal">{`${result} €`}</div>
- </div>
- )
- ) : null}
- {challenge.badge === BadgeState.SUCCESS ? (
- <div className="cp-win-badge-star">
- <img
- className="cp-win-badge"
- src={badgeIcon}
- width={screenType === ScreenType.MOBILE ? 200 : 300}
- ></img>
- <img
- className="cp-win-star"
- src={StarIcon}
- width={screenType === ScreenType.MOBILE ? 380 : 480}
- ></img>
- </div>
- ) : (
- <img
- className="cp-win-badge"
- src={badgeIcon}
- width={screenType === ScreenType.MOBILE ? 200 : 300}
- ></img>
- )}
- <div className="cp-description text-16-bold">
- {challenge.challengeType &&
- challenge.challengeType.description}
- </div>
- </div>
- <div className="cp-bottom">
- <div className="cp-eg-content text-14-normal-uppercase">
- {t('CHALLENGE.LINKED_ECOGESTURES')}
- <div className="cp-ecogestures">
- {challenge.selectedEcogestures
- .filter((eg, index) => index < 2)
- .map((eg, index) => (
- <EcogestureCard
- key={index}
- ecogesture={eg}
- handleClick={() => handleClick(index)}
- challengeEcogesture={index + 1}
- />
- ))}
- </div>
- </div>
- </div>
- </div>
- </div>
- {openEcogestureModal && (
- <EcogestureModal
- open={openEcogestureModal}
- ecogesture={challenge.selectedEcogestures[challengeEcogesture]}
- handleCloseClick={handleCloseClick}
- unlockedEcogesture={true}
- />
- )}
- </>
- )}
- </Content>
- </React.Fragment>
- )
-}
-
-export default FinishedChallengeDetailsView
diff --git a/src/components/Challenge/LockedChallengeDetailsViewContainer.tsx b/src/components/Challenge/LockedChallengeDetailsViewContainer.tsx
deleted file mode 100644
index 1c64e8c9f305690d2e5f4f36f9a11cfec60d7c12..0000000000000000000000000000000000000000
--- a/src/components/Challenge/LockedChallengeDetailsViewContainer.tsx
+++ /dev/null
@@ -1,91 +0,0 @@
-import React, { useState, useEffect } from 'react'
-import { useI18n } from 'cozy-ui/transpiled/react/I18n'
-import { Redirect } from 'react-router-dom'
-import { useRecoilValue } from 'recoil'
-import { Location } from 'history'
-
-import { ScreenType } from 'enum/screen.enum'
-import { screenTypeState } from 'atoms/screenType.state'
-import { ChallengeType } from 'models'
-
-import CozyBar from 'components/Header/CozyBar'
-import Header from 'components/Header/Header'
-import Content from 'components/Content/Content'
-import { history } from 'components/App'
-import StyledSpinner from 'components/CommonKit/Spinner/StyledSpinner'
-import StyledButtonValid from 'components/CommonKit/Button/StyledButtonValid'
-import LockedChallengeIcon from 'assets/png/badges/locked-big.png'
-
-interface LockedChallengeDetailsViewProps {
- location: Location<ChallengeType>
-}
-
-const LockedChallengeDetailsViewContainer: React.FC<LockedChallengeDetailsViewProps> = ({
- location,
-}: LockedChallengeDetailsViewProps) => {
- const { t } = useI18n()
- const screenType = useRecoilValue(screenTypeState)
- const [challenge, setChallenge] = useState<ChallengeType | null>(null)
- const [headerHeight, setHeaderHeight] = useState<number>(0)
- const challengeState = location.state
-
- const defineHeaderHeight = (height: number) => {
- setHeaderHeight(height)
- }
-
- useEffect(() => {
- if (challengeState) {
- setChallenge(challengeState)
- }
- }, [])
-
- return (
- <React.Fragment>
- <CozyBar
- titleKey={'COMMON.APP_LOCKED_CHALLENGE_TITLE'}
- displayBackArrow={true}
- />
- <Header
- setHeaderHeight={defineHeaderHeight}
- desktopTitleKey={'COMMON.APP_LOCKED_CHALLENGE_TITLE'}
- displayBackArrow={true}
- ></Header>
- {!challengeState ? <Redirect to="/challenges" /> : null}
- <Content height={headerHeight} background="var(--darkLight2)">
- {!challenge ? (
- <StyledSpinner />
- ) : (
- <>
- <div className="cp-root --locked">
- <div className="cp-content --locked">
- <div className="cp-info">
- <div className="cp-title text-22-bold">{challenge.title}</div>
- <img
- className="cp-icon"
- src={LockedChallengeIcon}
- width={screenType === ScreenType.MOBILE ? 180 : 220}
- ></img>
- <div className="cp-description text-16-bold">
- {challenge.level < 900
- ? t('CHALLENGE.LOCKED')
- : t('CHALLENGE.FULLY_LOCKED')}
- </div>
- </div>
- <div className="cp-valid-locked">
- <StyledButtonValid
- color="primary"
- onClick={() => history.goBack()}
- >
- {t('CHALLENGE.BACK')}
- </StyledButtonValid>
- </div>
- </div>
- </div>
- </>
- )}
- </Content>
- </React.Fragment>
- )
-}
-
-export default LockedChallengeDetailsViewContainer
diff --git a/src/components/Challenge/OngoingChallengeDetailsView.tsx b/src/components/Challenge/OngoingChallengeDetailsView.tsx
deleted file mode 100644
index a8c9ba2253bab25cacbc11f5ef954f6a1957186e..0000000000000000000000000000000000000000
--- a/src/components/Challenge/OngoingChallengeDetailsView.tsx
+++ /dev/null
@@ -1,197 +0,0 @@
-import React, { useState, useEffect, useCallback } from 'react'
-import { Redirect } from 'react-router-dom'
-import { useI18n } from 'cozy-ui/transpiled/react/I18n'
-import { useClient } from 'cozy-client'
-import { useRecoilState, useRecoilValue, useSetRecoilState } from 'recoil'
-import { Location } from 'history'
-
-import { TypeChallenge } from 'enum/challenge.enum'
-import { ScreenType } from 'enum/screen.enum'
-import { UserChallenge, UserProfile } from 'models'
-import { userProfileState } from 'atoms/userProfile.state'
-import { fluidTypeState } from 'atoms/fluidState.state'
-import { screenTypeState } from 'atoms/screenType.state'
-import { currentChallengeState } from 'atoms/challenge.state'
-import ChallengeService from 'services/challenge.service'
-import UserProfileService from 'services/userProfile.service'
-import { formatCompareChallengeDate } from 'utils/date'
-
-import CozyBar from 'components/Header/CozyBar'
-import Header from 'components/Header/Header'
-import Content from 'components/Content/Content'
-import { history } from 'components/App'
-import StyledSpinner from 'components/CommonKit/Spinner/StyledSpinner'
-import EcogestureModal from 'components/Ecogesture/EcogestureModal'
-import EcogestureCard from 'components/Ecogesture/EcogestureCard'
-import StyledStopButton from 'components/CommonKit/Button/StyledStopButton'
-import ChallengePile from 'components/Challenge/ChallengePile'
-import ChallengeViewingDate from 'components/Challenge/ChallengeViewingDate'
-import ChallengeTimeline from 'components/Challenge/ChallengeTimeline'
-import AvailableChallengeIcon from 'assets/png/badges/available.png'
-
-interface OngoingChallengeDetailsViewProps {
- location: Location<UserChallenge>
-}
-
-const OngoingChallengeDetailsView: React.FC<OngoingChallengeDetailsViewProps> = ({
- location,
-}: OngoingChallengeDetailsViewProps) => {
- const { t } = useI18n()
- const client = useClient()
- const screenType = useRecoilValue(screenTypeState)
- const fluidTypes = useRecoilValue(fluidTypeState)
- const [userProfile, setUserProfile] = useRecoilState<UserProfile>(
- userProfileState
- )
- const setCurrentChallenge = useSetRecoilState(currentChallengeState)
-
- const userChallengeState = location.state
- const [challengeEcogesture, setChallengeEcogesture] = useState<number>(0)
- const [openEcogestureModal, setOpenEcogestureModal] = useState(false)
- const [challenge, setChallenge] = useState<UserChallenge | null>(null)
- const [headerHeight, setHeaderHeight] = useState<number>(0)
- const [maxEnergy, setMaxEnergy] = useState<number | null>(0)
-
- const challengeService = new ChallengeService(client)
- const userProfileService = new UserProfileService(client)
-
- const defineHeaderHeight = (height: number) => {
- setHeaderHeight(height)
- }
-
- const updateUserProfileNotification = useCallback(
- async (ecogestureList: string[]) => {
- await userProfileService
- .updateUserProfile({ notificationEcogesture: ecogestureList })
- .then(updatedUserProfile => {
- updatedUserProfile && setUserProfile(updatedUserProfile)
- })
- },
- [setUserProfile]
- )
-
- async function stopChallenge(_challenge: UserChallenge) {
- if (_challenge && _challenge.id) {
- await challengeService.cancelChallenge(_challenge.id)
- const updatednotificationEcogesture = userProfile.notificationEcogesture.filter(
- (x: string) =>
- x !== _challenge.selectedEcogestures[0].id &&
- x !== _challenge.selectedEcogestures[1].id
- )
- await updateUserProfileNotification(updatednotificationEcogesture)
- setCurrentChallenge(null)
- history.goBack()
- }
- }
-
- const handleClick = (index: number) => {
- setChallengeEcogesture(index)
- setOpenEcogestureModal(true)
- }
-
- const handleCloseClick = () => {
- setOpenEcogestureModal(false)
- }
-
- useEffect(() => {
- if (userChallengeState) {
- setChallenge(userChallengeState)
- setMaxEnergy(userChallengeState.maxEnergy)
- }
- }, [])
-
- return (
- <React.Fragment>
- <CozyBar
- titleKey={'COMMON.APP_ONGOING_CHALLENGE_TITLE'}
- displayBackArrow={true}
- />
- <Header
- setHeaderHeight={defineHeaderHeight}
- desktopTitleKey={'COMMON.APP_ONGOING_CHALLENGE_TITLE'}
- displayBackArrow={true}
- ></Header>
- {!location.state ? <Redirect to="/challenges" /> : null}
- <Content height={headerHeight} background="var(--darkLight2)">
- {!challenge ? (
- <StyledSpinner />
- ) : (
- <>
- <div className="cp-root ongoing-challenge">
- <div className="cp-content">
- <div className="cp-info">
- <div className="cp-title text-22-bold">
- {challenge.challengeType && challenge.challengeType.title}
- </div>
- {challenge.challengeType &&
- challenge.challengeType.type === TypeChallenge.ACHIEVEMENT ? (
- <img
- className="cp-icon-available"
- src={AvailableChallengeIcon}
- width={screenType === ScreenType.MOBILE ? 180 : 250}
- ></img>
- ) : (
- <div className="cp-follow">
- {maxEnergy && maxEnergy === -1 && (
- <ChallengeViewingDate challenge={challenge} />
- )}
- <ChallengePile challenge={challenge} />
- <ChallengeTimeline challenge={challenge} />
- </div>
- )}
- <div className="cp-description text-16-bold">
- {challenge.challengeType &&
- challenge.challengeType.description}
- {challenge.challengeType &&
- challenge.challengeType.type === 1
- ? null
- : formatCompareChallengeDate(challenge)}
- </div>
- {challenge.challengeType &&
- challenge.challengeType.type !==
- TypeChallenge.ACHIEVEMENT && (
- <div className="cp-valid --ongoing">
- <StyledStopButton
- color="secondary"
- onClick={() => stopChallenge(challenge)}
- >
- {t('CHALLENGE.STOP')}
- </StyledStopButton>
- </div>
- )}
- </div>
- <div className="cp-bottom">
- <div className="cp-eg-content">
- <span className="linked-ecogestures">
- {t('CHALLENGE.LINKED_ECOGESTURES')}
- </span>
- <div className="cp-ecogestures">
- {challenge.selectedEcogestures.map((eg, index) => (
- <EcogestureCard
- key={index}
- ecogesture={eg}
- handleClick={() => handleClick(index)}
- challengeEcogesture={index + 1}
- />
- ))}
- </div>
- </div>
- </div>
- </div>
- </div>
- {openEcogestureModal && (
- <EcogestureModal
- open={openEcogestureModal}
- ecogesture={challenge.selectedEcogestures[challengeEcogesture]}
- handleCloseClick={handleCloseClick}
- unlockedEcogesture={true}
- />
- )}
- </>
- )}
- </Content>
- </React.Fragment>
- )
-}
-
-export default OngoingChallengeDetailsView
diff --git a/src/components/Connection/ConnectionForm.tsx b/src/components/Connection/ConnectionForm.tsx
index 36f9e62a732ed5f01ec92a48b28c093794951a97..31332ed049355f89f54fe948997a9ac79c398b9b 100644
--- a/src/components/Connection/ConnectionForm.tsx
+++ b/src/components/Connection/ConnectionForm.tsx
@@ -1,10 +1,10 @@
import React, { useCallback } from 'react'
import { useClient } from 'cozy-client'
-import { useSetRecoilState } from 'recoil'
+import { useDispatch } from 'react-redux'
+import { updateProfile } from 'store/profile/profile.actions'
-import { userProfileState } from 'atoms/userProfile.state'
import { Konnector, Trigger, FluidConfig } from 'models'
-import UserProfileService from 'services/userProfile.service'
+import ProfileService from 'services/profile.service'
import ConnectionLoginForm from 'components/Connection/ConnectionLoginForm'
import ConnectionOAuthForm from 'components/Connection/ConnectionOAuthForm'
@@ -25,17 +25,19 @@ const ConnectionForm: React.FC<ConnectionFormProps> = ({
handleSuccessForm,
}: ConnectionFormProps) => {
const client = useClient()
- const setUserProfile = useSetRecoilState(userProfileState)
+ const dispatch = useDispatch()
const oAuth: boolean = fluidConfig.konnectorConfig.oauth
const updateProfileHaveSeenOldFluidModal = useCallback(async () => {
- const userProfileService = new UserProfileService(client)
- await userProfileService
- .updateUserProfile({ haveSeenOldFluidModal: false })
- .then(updatedUserProfile => {
- updatedUserProfile && setUserProfile(updatedUserProfile)
+ const profileService = new ProfileService(client)
+ await profileService
+ .updateProfile({ haveSeenOldFluidModal: false })
+ .then(updatedProfile => {
+ if (updatedProfile) {
+ dispatch(updateProfile(updatedProfile))
+ }
})
- }, [setUserProfile])
+ }, [])
const handleSuccess = async (_account: Account, _trigger: Trigger) => {
await updateProfileHaveSeenOldFluidModal()
diff --git a/src/components/Connection/ConnectionResult.tsx b/src/components/Connection/ConnectionResult.tsx
index 5aec1475387eacc2489aeb3fa4951f97a8e8bb75..a691ac3ba5462fc1fa814ef0b468018bd10384b1 100644
--- a/src/components/Connection/ConnectionResult.tsx
+++ b/src/components/Connection/ConnectionResult.tsx
@@ -1,19 +1,18 @@
import React, { useState, useEffect, useCallback } from 'react'
import { useI18n } from 'cozy-ui/transpiled/react/I18n'
import { useClient } from 'cozy-client'
-import { useRecoilValue, useSetRecoilState } from 'recoil'
+import { useSetRecoilState } from 'recoil'
+import { useDispatch } from 'react-redux'
+import { updateProfile } from 'store/profile/profile.actions'
import { isKonnectorRunning } from 'cozy-harvest-lib/dist/helpers/triggers'
import { getKonnectorUpdateError } from 'utils/utils'
import { Account, Konnector, Trigger } from 'models'
-import { userProfileState } from 'atoms/userProfile.state'
-import { fluidStatusState, fluidTypeState } from 'atoms/fluidState.state'
-import { challengeNotificationState } from 'atoms/notification.state'
-import ChallengeService from 'services/challenge.service'
+import { fluidStatusState } from 'atoms/fluidState.state'
import TriggerService from 'services/triggers.service'
import AccountService from 'services/account.service'
import FluidService from 'services/fluid.service'
-import UserProfileService from 'services/userProfile.service'
+import ProfileService from 'services/profile.service'
import ConnectionFlow, {
ERROR_EVENT,
@@ -38,6 +37,7 @@ const ConnectionResult: React.FC<ConnectionResultProps> = ({
}: ConnectionResultProps) => {
const { t } = useI18n()
const client = useClient()
+ const dispatch = useDispatch()
const [trigger, setTrigger] = useState<Trigger | null>(null)
const [updating, setUpdating] = useState<boolean>(false)
const [lastExecutionDate, setLastExecutionDate] = useState<string>('-')
@@ -45,39 +45,25 @@ const ConnectionResult: React.FC<ConnectionResultProps> = ({
const [status, setStatus] = useState<string>('')
const setFluidStatusState = useSetRecoilState(fluidStatusState)
- const fluidTypes = useRecoilValue(fluidTypeState)
- const setChallengeNotificationState = useSetRecoilState(
- challengeNotificationState
- )
- const setUserProfile = useSetRecoilState(userProfileState)
const refreshFluidState = async () => {
const fluidService = new FluidService(client)
const fluidStatus = await fluidService.getFluidStatus()
if (fluidStatus) {
setFluidStatusState(fluidStatus)
- const challengeService = new ChallengeService(client)
- const achievement = await challengeService.checkAchievement('CHA00000001')
- if (achievement) {
- const notificationChallenge = await challengeService.isCurrentChallengeOver(
- achievement,
- fluidTypes
- )
- if (notificationChallenge) {
- setChallengeNotificationState(notificationChallenge)
- }
- }
}
}
const updateProfileHaveSeenOldFluidModal = useCallback(async () => {
- const userProfileService = new UserProfileService(client)
- await userProfileService
- .updateUserProfile({ haveSeenOldFluidModal: false })
- .then(updatedUserProfile => {
- updatedUserProfile && setUserProfile(updatedUserProfile)
+ const profileService = new ProfileService(client)
+ await profileService
+ .updateProfile({ haveSeenOldFluidModal: false })
+ .then(updatedProfile => {
+ if (updatedProfile) {
+ dispatch(updateProfile(updatedProfile))
+ }
})
- }, [setUserProfile])
+ }, [])
const updateState = async (_trigger: Trigger) => {
const triggerService = new TriggerService(client)
diff --git a/src/components/Content/Content.tsx b/src/components/Content/Content.tsx
index b5b0e5f4ce294871fc6a415aed239fef6a66b9e3..2cacb0c80798f411d080b9f123e7a76a757a2765 100644
--- a/src/components/Content/Content.tsx
+++ b/src/components/Content/Content.tsx
@@ -1,16 +1,15 @@
import React, { useCallback, useEffect } from 'react'
import { useClient } from 'cozy-client'
+import { history } from 'components/App'
import { useSelector, useDispatch } from 'react-redux'
import { EcolyoState } from 'store'
+import { changeScreenType } from 'store/global/global.actions'
import { updateModalIsFeedbacksOpen } from 'store/modal/modal.actions'
-import { useRecoilState } from 'recoil'
-import { history } from 'components/App'
+import { updateProfile } from 'store/profile/profile.actions'
+
+import ProfileService from 'services/profile.service'
import MailService from 'services/mail.service'
import { ScreenType } from 'enum/screen.enum'
-import { UserProfile } from 'models'
-import { userProfileState } from 'atoms/userProfile.state'
-import { screenTypeState } from 'atoms/screenType.state'
-import UserProfileService from 'services/userProfile.service'
import get from 'lodash/get'
import WelcomeModal from 'components/Welcome/WelcomeModal'
@@ -29,21 +28,18 @@ const Content: React.FC<ContentProps> = ({
background = 'inherit',
}: ContentProps) => {
const client = useClient()
+ const dispatch = useDispatch()
+ const { screenType } = useSelector((state: EcolyoState) => state.global)
+ const profile = useSelector((state: EcolyoState) => state.profile)
+ const modalState = useSelector((state: EcolyoState) => state.modal)
+ const mailService = new MailService()
+
const cozyBarHeight = 48
const cozyNavHeight = 56
- const mailService = new MailService()
- const [screenType, setScreenType] = useRecoilState<ScreenType>(
- screenTypeState
- )
- const [userProfile, setUserProfile] = useRecoilState<UserProfile>(
- userProfileState
- )
- const modalState = useSelector((state: EcolyoState) => state.modal)
- const dispatch = useDispatch()
const setWelcomeModalViewed = useCallback(async () => {
let username = ''
- // Retrieve public name from the stack
+ // TODO Move this code to Mail Service
const settings = await client
.getStackClient()
.fetchJSON('GET', '/settings/instance')
@@ -66,23 +62,28 @@ const Content: React.FC<ContentProps> = ({
],
}
mailService.SendMail(client, mailData)
- const userProfileService = new UserProfileService(client)
- await userProfileService
- .updateUserProfile({
+ const profileService = new ProfileService(client)
+ await profileService
+ .updateProfile({
isFirstConnection: false,
})
- .then(updatedUserProfile => {
- updatedUserProfile && setUserProfile(updatedUserProfile)
+ .then(updatedProfile => {
+ if (updatedProfile) {
+ dispatch(updateProfile(updatedProfile))
+ }
})
- }, [setUserProfile])
+ }, [])
+
const setFavoriteModalViewed = useCallback(async () => {
- const userProfileService = new UserProfileService(client)
- await userProfileService
- .updateUserProfile({ haveSeenFavoriteModal: true })
- .then(updatedUserProfile => {
- updatedUserProfile && setUserProfile(updatedUserProfile)
+ const profileService = new ProfileService(client)
+ await profileService
+ .updateProfile({ haveSeenFavoriteModal: true })
+ .then(updatedProfile => {
+ if (updatedProfile) {
+ dispatch(updateProfile(updatedProfile))
+ }
})
- }, [setUserProfile])
+ }, [])
const handleFeedbackModalClose = () => {
dispatch(updateModalIsFeedbacksOpen(false))
@@ -100,11 +101,11 @@ const Content: React.FC<ContentProps> = ({
useEffect(() => {
function handleResize() {
if (innerWidth <= 768) {
- setScreenType(ScreenType.MOBILE)
+ dispatch(changeScreenType(ScreenType.MOBILE))
} else if (innerWidth <= 1024) {
- setScreenType(ScreenType.TABLET)
+ dispatch(changeScreenType(ScreenType.TABLET))
} else {
- setScreenType(ScreenType.DESKTOP)
+ dispatch(changeScreenType(ScreenType.DESKTOP))
}
}
handleResize()
@@ -117,7 +118,7 @@ const Content: React.FC<ContentProps> = ({
return (
<>
<WelcomeModal
- open={userProfile.isFirstConnection}
+ open={profile.isFirstConnection}
handleCloseClick={setWelcomeModalViewed}
/>
<FeedbackModal
@@ -125,9 +126,7 @@ const Content: React.FC<ContentProps> = ({
handleCloseClick={handleFeedbackModalClose}
/>
<FavoriteModal
- open={
- !userProfile.isFirstConnection && !userProfile.haveSeenFavoriteModal
- }
+ open={!profile.isFirstConnection && !profile.haveSeenFavoriteModal}
handleCloseClick={setFavoriteModalViewed}
/>
<div
diff --git a/src/components/Ecogesture/EcogestureCard.tsx b/src/components/Ecogesture/EcogestureCard.tsx
index 9751661b006823bad4077d467b66b3210df70f41..bc58ae8cdaa9ca3291b7a82d2f8a457c973037dc 100644
--- a/src/components/Ecogesture/EcogestureCard.tsx
+++ b/src/components/Ecogesture/EcogestureCard.tsx
@@ -1,9 +1,5 @@
import React, { useState, useEffect } from 'react'
-import { useRecoilValue } from 'recoil'
-
import { Ecogesture } from 'models'
-import { userProfileState } from 'atoms/userProfile.state'
-
import StyledEcogestureCard from 'components/CommonKit/Card/StyledEcogestureCard'
import def from 'assets/icons/visu/ecogesture/default.svg'
import StyledIcon from 'components/CommonKit/Icon/StyledIcon'
@@ -17,15 +13,11 @@ interface EcogestureCardProps {
const EcogestureCard: React.FC<EcogestureCardProps> = ({
ecogesture,
handleClick,
- challengeEcogesture,
}: EcogestureCardProps) => {
const handleCardclick = () => {
handleClick && ecogesture && handleClick(ecogesture)
}
const [ecogestureIcon, setEcogestureIcon] = useState(def)
- const userProfile = useRecoilValue(userProfileState)
- const newEcogestures: string[] | null =
- userProfile && userProfile.notificationEcogesture
async function importEcogestureIcon(id: string) {
// Les svg doivent être au format id.svg
let importedEcogesture
@@ -47,65 +39,28 @@ const EcogestureCard: React.FC<EcogestureCardProps> = ({
return (
<>
- {challengeEcogesture ? (
- <div className={`cp-eg-${challengeEcogesture}`}>
- <StyledEcogestureCard
- border={true}
- onClick={handleCardclick}
- newEcogesture={
- newEcogestures && newEcogestures.includes(ecogesture.id)
- }
+ <StyledEcogestureCard unlocked={true} onClick={handleCardclick}>
+ <div className="ec">
+ <div
+ className={`ec-content ${
+ ecogesture.unlocked ? 'ec-content-unlocked' : ''
+ }`}
>
- <div className="ec">
- <div className="ec-content ec-content-challenge">
- <div>
- <StyledIcon
- className="Icon"
- icon={ecogestureIcon}
- size={64}
- />
- </div>
- <div className="ec-content-challenge-text">
- {ecogesture.shortName}
- </div>
- </div>
+ <div className="ec-content-icon">
+ {ecogesture.unlocked && (
+ <StyledIcon className="Icon" icon={ecogestureIcon} size={50} />
+ )}
</div>
- </StyledEcogestureCard>
- </div>
- ) : (
- <StyledEcogestureCard
- unlocked={ecogesture.unlocked ? ecogesture.unlocked : false}
- onClick={handleCardclick}
- newEcogesture={
- newEcogestures && newEcogestures.includes(ecogesture.id)
- }
- >
- <div className="ec">
- <div
- className={`ec-content ${
- ecogesture.unlocked ? 'ec-content-unlocked' : ''
- }`}
- >
- <div className="ec-content-icon">
- {ecogesture.unlocked && (
- <StyledIcon
- className="Icon"
- icon={ecogestureIcon}
- size={50}
- />
- )}
- </div>
- <div className="ec-content-short-name text-16-bold">
- {ecogesture.shortName}
- </div>
- <div className="ec-content-nwh">
- <span className="text-16-bold">{ecogesture.nwh}</span>
- <span className="text-16-normal"> nWh</span>
- </div>
+ <div className="ec-content-short-name text-16-bold">
+ {ecogesture.shortName}
+ </div>
+ <div className="ec-content-nwh">
+ <span className="text-16-bold">{ecogesture.nwh}</span>
+ <span className="text-16-normal"> nWh</span>
</div>
</div>
- </StyledEcogestureCard>
- )}
+ </div>
+ </StyledEcogestureCard>
</>
)
}
diff --git a/src/components/Ecogesture/EcogestureList.tsx b/src/components/Ecogesture/EcogestureList.tsx
index 0fb4ef3d0f2c9f0ca5bd1b8ecf754a8147cfc529..7d221c38d6fbfd24bc4ea5cdac9ce57bccbb5e45 100644
--- a/src/components/Ecogesture/EcogestureList.tsx
+++ b/src/components/Ecogesture/EcogestureList.tsx
@@ -4,7 +4,7 @@ import { useClient } from 'cozy-client'
import { Ecogesture } from 'models'
import { FluidType } from 'enum/fluid.enum'
-import ChallengeService from 'services/challenge.service'
+import EcogestureService from 'services/ecogesture.service'
import GasIcon from 'assets/icons/ico/gas.svg'
import ElecIcon from 'assets/icons/ico/elec.svg'
@@ -33,7 +33,7 @@ const EcogesturesList: React.FC = () => {
const [filterbyFluid, setfilterbyFluid] = useState<FluidType | null>(null)
const [ascendingSort, setascendingSort] = useState(false)
const [openDropDown, setopenDropDown] = useState(false)
- const _challengeService = new ChallengeService(client)
+ const ecogestureService = new EcogestureService(client)
const handleClick = (ecogesture: Ecogesture) => {
setSelectedEcogesture(ecogesture)
@@ -72,21 +72,12 @@ const EcogesturesList: React.FC = () => {
useEffect(() => {
let subscribed = true
async function loadEcogestures() {
- const dataAll = await _challengeService.getAllEcogestures()
- const dataUnlocked = await _challengeService.getUnlockedEcogestures()
+ const dataAll = await ecogestureService.getAllEcogestures()
if (subscribed && dataAll) {
- if (dataUnlocked) {
- dataAll.forEach(element => {
- if (dataUnlocked.includes(element.id)) {
- element.unlocked = true
- }
- })
- }
setEcogestures(dataAll)
}
}
loadEcogestures()
-
return () => {
subscribed = false
}
@@ -278,7 +269,7 @@ const EcogesturesList: React.FC = () => {
</div>
</>
)}
- {openEcogestureModal && (
+ {openEcogestureModal && selectedEcogesture && (
<EcogestureModal
open={openEcogestureModal}
ecogesture={selectedEcogesture}
diff --git a/src/components/Ecogesture/EcogestureModal.tsx b/src/components/Ecogesture/EcogestureModal.tsx
index 125436bf6ef38176e493e508fe0bf21f718af0d9..5d3ae99f97c0fd00cfd2d03080d1db61fad6eaee 100644
--- a/src/components/Ecogesture/EcogestureModal.tsx
+++ b/src/components/Ecogesture/EcogestureModal.tsx
@@ -1,34 +1,26 @@
-import React, { useState, useEffect, useCallback } from 'react'
-import { useClient } from 'cozy-client'
+import React, { useState, useEffect } from 'react'
import { useI18n } from 'cozy-ui/transpiled/react/I18n'
-import { useRecoilState } from 'recoil'
import { getPicto } from 'utils/picto'
import { Ecogesture } from 'models'
-import { userProfileState } from 'atoms/userProfile.state'
import Modal from 'components/CommonKit/Modal/Modal'
import StyledIcon from 'components/CommonKit/Icon/StyledIcon'
import def from 'assets/icons/visu/ecogesture/default.svg'
-import UserProfileService from 'services/userProfile.service'
interface EcogestureModalProps {
open: boolean
ecogesture: Ecogesture
- unlockedEcogesture: boolean
handleCloseClick: () => void
}
const EcogestureModal: React.FC<EcogestureModalProps> = ({
open,
ecogesture,
- unlockedEcogesture,
handleCloseClick,
}: EcogestureModalProps) => {
const { t } = useI18n()
const [ecogestureIcon, setEcogestureIcon] = useState(def)
- const [userProfile, setUserProfile] = useRecoilState(userProfileState)
- const client = useClient()
async function importEcogestureIcon(id: string) {
// Les svg doivent être au format id.svg
@@ -43,32 +35,6 @@ const EcogestureModal: React.FC<EcogestureModalProps> = ({
}
}
- const updateUserProfileNotification = useCallback(
- async (ecogestureList: string[]) => {
- const userProfileService = new UserProfileService(client)
- await userProfileService
- .updateUserProfile({ notificationEcogesture: ecogestureList })
- .then(updatedUserProfile => {
- updatedUserProfile && setUserProfile(updatedUserProfile)
- })
- },
- [setUserProfile]
- )
-
- useEffect(() => {
- let index = -1
- if (userProfile && userProfile.notificationEcogesture != undefined) {
- index = userProfile.notificationEcogesture.indexOf(ecogesture.id)
- }
- if (index > -1) {
- const updatedNotificationEcogestureList = [
- ...userProfile.notificationEcogesture,
- ]
- updatedNotificationEcogestureList.splice(index, 1)
- updateUserProfileNotification(updatedNotificationEcogestureList)
- }
- }, [])
-
useEffect(() => {
if (ecogesture) {
importEcogestureIcon(ecogesture.id)
@@ -78,25 +44,20 @@ const EcogestureModal: React.FC<EcogestureModalProps> = ({
return (
<>
{ecogesture && (
- <Modal
- open={open}
- border={ecogesture.unlocked || unlockedEcogesture}
- handleCloseClick={handleCloseClick}
- >
+ <Modal open={open} border={true} handleCloseClick={handleCloseClick}>
<div className="em-header text-14-normal-uppercase">
{t('ECOGESTURE.TITLE_ECOGESTURE')}
</div>
<div className="em-root">
<div className="em-content">
<div className="em-content-box-img">
- {(ecogesture.unlocked || unlockedEcogesture) &&
- ecogestureIcon && (
- <StyledIcon
- className="icon"
- icon={ecogestureIcon}
- size={140}
- />
- )}
+ {ecogestureIcon && (
+ <StyledIcon
+ className="icon"
+ icon={ecogestureIcon}
+ size={140}
+ />
+ )}
</div>
<div className="em-title text-24-bold ">
{ecogesture.shortName}
diff --git a/src/components/Header/CozyBar.tsx b/src/components/Header/CozyBar.tsx
index d05ef4dd1a92223c613b01b7af76efca09769b66..4e907f4a00b54ddf2eed1ce989fc277ae2321c8d 100644
--- a/src/components/Header/CozyBar.tsx
+++ b/src/components/Header/CozyBar.tsx
@@ -1,12 +1,11 @@
import React from 'react'
import { useI18n } from 'cozy-ui/transpiled/react/I18n'
-import { useDispatch } from 'react-redux'
+import { useSelector, useDispatch } from 'react-redux'
+import { EcolyoState } from 'store'
import { updateModalIsFeedbacksOpen } from 'store/modal/modal.actions'
-import { useRecoilValue } from 'recoil'
import { history } from 'components/App'
import { ScreenType } from 'enum/screen.enum'
-import { screenTypeState } from 'atoms/screenType.state'
import BackArrowIcon from 'assets/icons/ico/back-arrow.svg'
import FeedbacksIcon from 'assets/icons/ico/feedbacks.svg'
@@ -22,9 +21,9 @@ const CozyBar = ({
displayBackArrow = false,
}: CozyBarProps) => {
const { t } = useI18n()
- const { BarLeft, BarCenter, BarRight } = cozy.bar
- const screenType = useRecoilValue(screenTypeState)
const dispatch = useDispatch()
+ const { BarLeft, BarCenter, BarRight } = cozy.bar
+ const { screenType } = useSelector((state: EcolyoState) => state.global)
const handleClickBack = () => {
history.goBack()
diff --git a/src/components/Header/Header.tsx b/src/components/Header/Header.tsx
index a5f72a78ddeff93ebac76875d8ecd2107125866e..5e4ecd59b4f00e6a50879909fe6c418379fbf80d 100644
--- a/src/components/Header/Header.tsx
+++ b/src/components/Header/Header.tsx
@@ -1,12 +1,11 @@
import React, { useEffect, useRef } from 'react'
import { useI18n } from 'cozy-ui/transpiled/react/I18n'
-import { useRecoilValue, useSetRecoilState } from 'recoil'
+import { useSelector, useDispatch } from 'react-redux'
+import { EcolyoState } from 'store'
+import { updateModalIsFeedbacksOpen } from 'store/modal/modal.actions'
import { history } from 'components/App'
import { ScreenType } from 'enum/screen.enum'
-import { ModalState } from 'models'
-import { modalState } from 'atoms/modal.state'
-import { screenTypeState } from 'atoms/screenType.state'
import BackArrowIcon from 'assets/icons/ico/back-arrow.svg'
import FeedbacksIcon from 'assets/icons/ico/feedbacks.svg'
@@ -29,8 +28,8 @@ const Header: React.FC<HeaderProps> = ({
}: HeaderProps) => {
const { t } = useI18n()
const header = useRef(null)
- const screenType = useRecoilValue(screenTypeState)
- const setModalState = useSetRecoilState(modalState)
+ const dispatch = useDispatch()
+ const { screenType } = useSelector((state: EcolyoState) => state.global)
const cozyBarHeight = 48
const headerBottomHeight = 8
@@ -40,7 +39,7 @@ const Header: React.FC<HeaderProps> = ({
}
const handleClickFeedbacks = () => {
- setModalState((prev: ModalState) => ({ ...prev, feedbackModal: true }))
+ dispatch(updateModalIsFeedbacksOpen(true))
}
useEffect(() => {
diff --git a/src/components/Home/HomeView.tsx b/src/components/Home/HomeView.tsx
index e0d49a8380132cae380063e47aa8db5b5d0a809b..a34641b503d9938089c781445911cdc3d61e2dfa 100644
--- a/src/components/Home/HomeView.tsx
+++ b/src/components/Home/HomeView.tsx
@@ -1,6 +1,9 @@
import React, { useState, useEffect, useCallback } from 'react'
import { useClient } from 'cozy-client'
import { useRecoilState, useRecoilValue } from 'recoil'
+import { useSelector, useDispatch } from 'react-redux'
+import { EcolyoState } from 'store'
+import { updateProfile } from 'store/profile/profile.actions'
import { TimeStep } from 'enum/timeStep.enum'
import { fluidStatusState, fluidTypeState } from 'atoms/fluidState.state'
@@ -13,22 +16,22 @@ import Content from 'components/Content/Content'
import FluidChart from 'components/FluidChart/FluidChart'
import ConsumptionNavigator from 'components/ConsumptionNavigator/ConsumptionNavigator'
import HomeIndicators from 'components/Home/HomeIndicators'
-import ChallengeCardLink from 'components/Challenge/ChallengeCardLink'
import KonnectorViewerList from 'components/Konnector/KonnectorViewerList'
import OldFluidDataModal from 'components/Home/OldFluidDataModal'
import { DateTime } from 'luxon'
-import { userProfileState } from 'atoms/userProfile.state'
-import UserProfileService from 'services/userProfile.service'
+
+import ProfileService from 'services/profile.service'
import { FluidType } from 'enum/fluid.enum'
const HomeView: React.FC = () => {
const client = useClient()
+ const dispatch = useDispatch()
+ const profile = useSelector((state: EcolyoState) => state.profile)
const fluidTypes = useRecoilValue(fluidTypeState)
const fluidStatus = useRecoilValue(fluidStatusState)
const [previousTimeStep, setPreviousTimeStep] = useRecoilState(
previousTimeStepState
)
- const [userProfile, setUserProfile] = useRecoilState(userProfileState)
const [timeStep, setTimeStep] = useState<TimeStep>(
previousTimeStep !== TimeStep.HALF_AN_HOUR ? previousTimeStep : TimeStep.DAY
@@ -41,13 +44,15 @@ const HomeView: React.FC = () => {
const [fluidOldData] = useState<FluidType[]>([])
const updateProfileHaveSeenOldFluidModal = useCallback(async () => {
- const userProfileService = new UserProfileService(client)
- await userProfileService
- .updateUserProfile({ haveSeenOldFluidModal: DateTime.local() })
- .then(updatedUserProfile => {
- updatedUserProfile && setUserProfile(updatedUserProfile)
+ const profileService = new ProfileService(client)
+ await profileService
+ .updateProfile({ haveSeenOldFluidModal: DateTime.local() })
+ .then(updatedProfile => {
+ if (updatedProfile) {
+ dispatch(updateProfile(updatedProfile))
+ }
})
- }, [setUserProfile])
+ }, [])
const setChartLoaded = () => {
setChartLoading(false)
@@ -71,6 +76,7 @@ const HomeView: React.FC = () => {
const defineHeaderHeight = (height: number) => {
setHeaderHeight(height)
}
+
const checkFluidDataPeriod = async () => {
for (const fluid of fluidStatus) {
let diffInDays = 0
@@ -84,14 +90,17 @@ const HomeView: React.FC = () => {
}
}
if (fluidOldData.length > 0) {
- if (userProfile.haveSeenOldFluidModal === false) {
+ if (profile.haveSeenOldFluidModal === false) {
//if user never has never seen the modal
await updateProfileHaveSeenOldFluidModal()
return setopenOldFluidDataModal(true)
- } else if (userProfile.haveSeenOldFluidModal) {
- const dateToCompare = userProfile.haveSeenOldFluidModal
+ } else if (profile.haveSeenOldFluidModal) {
+ const dateToCompare = profile.haveSeenOldFluidModal
//if user has seen the modal since more than a day
- const diff = dateToCompare.diffNow('hours').toObject().hours
+ const diff =
+ typeof dateToCompare === 'boolean'
+ ? 0
+ : dateToCompare.diffNow('hours').toObject().hours
if (diff && diff < -23) {
updateProfileHaveSeenOldFluidModal()
return setopenOldFluidDataModal(true)
@@ -152,7 +161,6 @@ const HomeView: React.FC = () => {
timeStep={timeStep}
setIndicatorsLoaded={setIndicatorsLoaded}
/>
- <ChallengeCardLink />
</div>
</Content>
{fluidStatus && (
diff --git a/src/components/Navbar/Navbar.tsx b/src/components/Navbar/Navbar.tsx
index fbccff671ac123609b6a0a629ddd8a05efd0777f..922c3c1923402140a1248a0de2400082ba58a49b 100644
--- a/src/components/Navbar/Navbar.tsx
+++ b/src/components/Navbar/Navbar.tsx
@@ -1,6 +1,7 @@
import React from 'react'
import { useI18n } from 'cozy-ui/transpiled/react/I18n'
import { NavLink } from 'react-router-dom'
+import { useSelector } from 'react-redux'
import ConsoIconOn from 'assets/icons/tabbar/conso/conso-on.svg'
import ConsoIconOff from 'assets/icons/tabbar/conso/conso-off.svg'
@@ -15,16 +16,13 @@ import ReportIconOff from 'assets/icons/tabbar/bilan/bilan-off.svg'
import logoGrandLyon from 'assets/icons/tabbar/grand-lyon.svg'
import logoTiga from 'assets/png/logo-TIGA.png'
import StyledIcon from 'components/CommonKit/Icon/StyledIcon'
-import { useRecoilValue } from 'recoil'
-import {
- challengeNotificationState,
- reportNotificationState,
-} from 'atoms/notification.state'
+import { EcolyoState } from 'store'
export const Navbar: React.FC = () => {
const { t } = useI18n()
- const challengeNotification = useRecoilValue(challengeNotificationState)
- const reportNotification = useRecoilValue(reportNotificationState)
+ const { seasonNotification, reportNotification } = useSelector(
+ (state: EcolyoState) => state.global
+ )
return (
<aside className="o-sidebar">
@@ -47,7 +45,7 @@ export const Navbar: React.FC = () => {
className="c-nav-link"
activeClassName="is-active"
>
- {challengeNotification && <div className="nb-notif">1</div>}
+ {seasonNotification && <div className="nb-notif">1</div>}
<StyledIcon className="c-nav-icon off" icon={ChallengeIconOff} />
<StyledIcon className="c-nav-icon on" icon={ChallengeIconOn} />
{t('Nav.challenges')}
diff --git a/src/components/Options/ReportOptions.tsx b/src/components/Options/ReportOptions.tsx
index e4851d2fbd67bbcdf085f242dc05bbb32602ccbb..c4ba11a3c2ec73c70dbc673916682ee050e0548d 100644
--- a/src/components/Options/ReportOptions.tsx
+++ b/src/components/Options/ReportOptions.tsx
@@ -1,43 +1,32 @@
import React, { useCallback } from 'react'
import { useI18n } from 'cozy-ui/transpiled/react/I18n'
import { useClient } from 'cozy-client'
-import { useRecoilState } from 'recoil'
-import UserProfileService from 'services/userProfile.service'
-import { userProfileState } from 'atoms/userProfile.state'
-import { UserProfile } from 'models'
+import { useSelector, useDispatch } from 'react-redux'
+import { EcolyoState } from 'store'
+import { updateProfile } from 'store/profile/profile.actions'
+import ProfileService from 'services/profile.service'
const ReportOptions: React.FC = () => {
const { t } = useI18n()
const client = useClient()
- const [userProfile, setUserProfile] = useRecoilState<UserProfile>(
- userProfileState
- )
+ const dispatch = useDispatch()
+ const profile = useSelector((state: EcolyoState) => state.profile)
- const updateUserProfileReport = useCallback(
- async (value: boolean) => {
- const userProfileService = new UserProfileService(client)
- const reportAttributes = {
- sendReportNotification: value,
- haveSeenLastReport: userProfile.report.haveSeenLastReport,
- monthlyReportDate: userProfile.report.monthlyReportDate,
- }
- try {
- await userProfileService
- .updateUserProfile({ report: reportAttributes })
- .then(updatedUserProfile => {
- updatedUserProfile && setUserProfile(updatedUserProfile)
- })
- } catch (err) {
- console.log(err)
- }
- },
- [setUserProfile]
- )
+ const updateProfileReport = useCallback(async (value: boolean) => {
+ const profileService = new ProfileService(client)
+ await profileService
+ .updateProfile({ sendReportNotification: value })
+ .then(updatedProfile => {
+ if (updatedProfile) {
+ dispatch(updateProfile(updatedProfile))
+ }
+ })
+ }, [])
const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
e.target.value === 'true'
- ? updateUserProfileReport(true)
- : updateUserProfileReport(false)
+ ? updateProfileReport(true)
+ : updateProfileReport(false)
}
return (
@@ -55,8 +44,7 @@ const ReportOptions: React.FC = () => {
value="true"
onChange={handleChange}
checked={
- userProfile &&
- userProfile.report.sendReportNotification === true
+ profile && profile.sendReportNotification === true
? true
: false
}
@@ -71,8 +59,7 @@ const ReportOptions: React.FC = () => {
value="false"
onChange={handleChange}
checked={
- userProfile &&
- userProfile.report.sendReportNotification === false
+ profile && profile.sendReportNotification === false
? true
: false
}
diff --git a/src/components/Report/ChallengeItemReport.tsx b/src/components/Report/ChallengeItemReport.tsx
deleted file mode 100644
index dbdad5ba65c54c9ed56f1892bf07e4770f9d5373..0000000000000000000000000000000000000000
--- a/src/components/Report/ChallengeItemReport.tsx
+++ /dev/null
@@ -1,88 +0,0 @@
-import React, { useEffect, useState } from 'react'
-import './challengeitemreport.scss'
-import { NavLink } from 'react-router-dom'
-
-import { UserChallenge } from 'models'
-
-import StyledChallengeCard from 'components/CommonKit/Card/StyledChallengeCard'
-import StyledIcon from 'components/CommonKit/Icon/StyledIcon'
-import BlackArrowIcon from 'assets/icons/ico/black-arrow.svg'
-
-interface ChallengeItemReportProps {
- userChallenge: UserChallenge
-}
-
-const ChallengeItemReport: React.FC<ChallengeItemReportProps> = ({
- userChallenge,
-}: ChallengeItemReportProps) => {
- const [badgeSource, setBadgeSource] = useState<string>([])
-
- async function importRightBadge(
- id: string,
- badgeStatus: number
- ): Promise<string | undefined> {
- if (badgeStatus !== -1) {
- // Les png doivent être au format idchallenge-badgestate.png
- const importedBadge =
- id === 'CHA00000001'
- ? await import(
- /* webpackMode: "eager" */ `assets/png/badges/${id}-1.png`
- )
- : await import(
- /* webpackMode: "eager" */ `assets/png/badges/${id}-${badgeStatus}.png`
- )
- return importedBadge.default
- }
- }
-
- useEffect(() => {
- let subscribed = true
- async function getBadge() {
- if (userChallenge && userChallenge.challengeType) {
- const badge = await importRightBadge(
- userChallenge.challengeType.id,
- userChallenge.badge != null ? userChallenge.badge : 0
- )
- if (subscribed && badge) {
- setBadgeSource(badge)
- }
- }
- }
- getBadge()
- return () => {
- subscribed = false
- }
- }, [userChallenge.id])
-
- return (
- <NavLink
- className="challenge-card-link"
- to={{
- pathname: `challenges/finished`,
- state: userChallenge,
- }}
- >
- <StyledChallengeCard displayBorder={true}>
- <div className="challenge-card">
- <div className="challenge-card-content-left">
- <div className="challenge-card-content-badge">
- {badgeSource && (
- <img className="cp-win-badge" src={badgeSource} width={72} />
- )}
- </div>
- <div className="challenge-card-content-title text-18-normal">
- {userChallenge.challengeType
- ? userChallenge.challengeType.title
- : null}
- </div>
- </div>
- <div className="challenge-card-content-right">
- <StyledIcon icon={BlackArrowIcon} size={18} />
- </div>
- </div>
- </StyledChallengeCard>
- </NavLink>
- )
-}
-
-export default ChallengeItemReport
diff --git a/src/components/Report/ChallengeReport.tsx b/src/components/Report/ChallengeReport.tsx
deleted file mode 100644
index 35ceaf275e19cf8d0bb7139a90b1bec53b36a533..0000000000000000000000000000000000000000
--- a/src/components/Report/ChallengeReport.tsx
+++ /dev/null
@@ -1,23 +0,0 @@
-import React from 'react'
-import './challengereport.scss'
-
-import { UserChallenge } from 'models'
-import ChallengeItemReport from 'components/Report/ChallengeItemReport'
-
-interface ChallengeReportProps {
- userChallenges: UserChallenge[]
-}
-
-const ChallengeReport: React.FC<ChallengeReportProps> = ({
- userChallenges,
-}: ChallengeReportProps) => {
- return (
- <div className="challenge-root">
- {userChallenges.map((userChallenge, index) => {
- return <ChallengeItemReport key={index} userChallenge={userChallenge} />
- })}
- </div>
- )
-}
-
-export default ChallengeReport
diff --git a/src/components/Report/MonthlyReport.tsx b/src/components/Report/MonthlyReport.tsx
index e73bfdfccf019b3257b3698023ac2e1cb8f99251..139c3388f43937997ef8252c41a6e1a7fc20f4fc 100644
--- a/src/components/Report/MonthlyReport.tsx
+++ b/src/components/Report/MonthlyReport.tsx
@@ -8,18 +8,16 @@ import './monthlyreport.scss'
import { TimeStep } from 'enum/timeStep.enum'
import { fluidTypeState } from 'atoms/fluidState.state'
import { userProfileState } from 'atoms/userProfile.state'
-import { PerformanceIndicator, UserChallenge } from 'models'
+import { PerformanceIndicator } from 'models'
import ConsumptionService from 'services/consumption.service'
import PerformanceIndicatorService from 'services/performanceIndicator.service'
import ConfigService from 'services/fluidConfig.service'
-import ChallengeService from 'services/challenge.service'
import { convertDateToMonthString } from 'utils/date'
import PerformanceIndicatorContent from 'components/PerformanceIndicator/PerformanceIndicatorContent'
import FluidPerformanceIndicator from 'components/PerformanceIndicator/FluidPerformanceIndicator'
import DateNavigator from 'components/DateNavigator/DateNavigator'
import ChartReport from 'components/Report/ChartReport'
-import ChallengeReport from 'components/Report/ChallengeReport'
import { FluidType } from 'enum/fluid.enum'
const MonthlyReport: React.FC = () => {
@@ -41,15 +39,11 @@ const MonthlyReport: React.FC = () => {
compareValue: 0,
percentageVariation: 0,
})
- const [userChallenges, setUserChallenges] = useState<UserChallenge[] | null>(
- null
- )
const [isLoaded, setIsLoaded] = useState<boolean>(false)
const [fluidLackOfData, setFluidLackOfData] = useState<Array<FluidType>>([])
const consumptionService = new ConsumptionService(client)
const performanceIndicatorService = new PerformanceIndicatorService()
- const challengeService = new ChallengeService(client)
const configService = new ConfigService()
const fluidConfig = configService.getFluidConfig()
const timeStep = TimeStep.MONTH
@@ -78,9 +72,6 @@ const MonthlyReport: React.FC = () => {
fluidTypes,
periods.comparisonTimePeriod
)
- const userChallengesDone = await challengeService.getFinishedUserChallengesOnMonth(
- reportDate.minus({ month: 1 })
- )
if (subscribed) {
if (fetchedPerformanceIndicators) {
const fluidLackOfDataIndicators: Array<FluidType> = []
@@ -97,9 +88,6 @@ const MonthlyReport: React.FC = () => {
)
)
}
- if (userChallengesDone) {
- setUserChallenges(userChallengesDone)
- }
setIsLoaded(true)
}
}
@@ -170,20 +158,6 @@ const MonthlyReport: React.FC = () => {
) : null
})}
</div>
- <div>
- {userChallenges && userChallenges.length > 0 ? (
- <div className="report-header text-16-normal-uppercase ">
- {t('report.challenge') +
- ' ' +
- reportDate
- .plus({ month: -1 })
- .toLocaleString({ locale: 'fr-FR', month: 'long' })}
- </div>
- ) : null}
- {userChallenges && (
- <ChallengeReport userChallenges={userChallenges} />
- )}
- </div>
</div>
</div>
</div>
diff --git a/src/components/Report/ReportView.tsx b/src/components/Report/ReportView.tsx
index 30c7b154d734ede145ffadb8876d746baf0774c5..d88bea4e0d7784ca9abb68d90da940927882a9e2 100644
--- a/src/components/Report/ReportView.tsx
+++ b/src/components/Report/ReportView.tsx
@@ -1,10 +1,10 @@
import React, { useState, useEffect } from 'react'
import { useClient } from 'cozy-client'
-import { useRecoilState } from 'recoil'
-
-import { ReportAttributes, UserProfile } from 'models'
-import { userProfileState } from 'atoms/userProfile.state'
-import UserProfileService from 'services/userProfile.service'
+import { useSelector, useDispatch } from 'react-redux'
+import { updateProfile } from 'store/profile/profile.actions'
+import { toogleReportNotification } from 'store/global/global.actions'
+import { EcolyoState } from 'store'
+import ProfileService from 'services/profile.service'
import CozyBar from 'components/Header/CozyBar'
import Header from 'components/Header/Header'
@@ -13,10 +13,11 @@ import MonthlyReport from 'components/Report/MonthlyReport'
const ReportView: React.FC = () => {
const client = useClient()
- const [userProfile, setUserProfile] = useRecoilState<UserProfile>(
- userProfileState
- )
const [headerHeight, setHeaderHeight] = useState<number>(0)
+ const { reportNotification } = useSelector(
+ (state: EcolyoState) => state.global
+ )
+ const dispatch = useDispatch()
const defineHeaderHeight = (height: number) => {
setHeaderHeight(height)
}
@@ -24,20 +25,16 @@ const ReportView: React.FC = () => {
useEffect(() => {
let subscribed = true
const updateUserProfileReport = async () => {
- if (!userProfile.report.haveSeenLastReport) {
- const reportAttributes: ReportAttributes = {
- sendReportNotification: userProfile.report.sendReportNotification,
- haveSeenLastReport: true,
- monthlyReportDate: userProfile.report.monthlyReportDate,
- }
- const userProfileService = new UserProfileService(client)
+ if (reportNotification) {
+ const profileService = new ProfileService(client)
try {
- await userProfileService
- .updateUserProfile({ report: reportAttributes })
- .then(updatedUserProfile => {
- subscribed &&
- updatedUserProfile &&
- setUserProfile(updatedUserProfile)
+ await profileService
+ .updateProfile({ haveSeenLastReport: true })
+ .then(updatedProfile => {
+ if (subscribed && updatedProfile) {
+ dispatch(updateProfile(updatedProfile))
+ dispatch(toogleReportNotification(true))
+ }
})
} catch (err) {
console.log(err)
diff --git a/src/components/Report/challengeitemreport.scss b/src/components/Report/challengeitemreport.scss
deleted file mode 100644
index 515b667acdd5da97c8cfe34de98032a6149b9827..0000000000000000000000000000000000000000
--- a/src/components/Report/challengeitemreport.scss
+++ /dev/null
@@ -1,36 +0,0 @@
-@import '../../styles/base/color';
-@import '../../styles/base/breakpoint';
-
-.challenge-card-link {
- color: black;
- text-decoration: none;
-}
-.challenge-card {
- cursor: pointer;
- display: flex;
- flex-direction: row;
- width: 100%;
- .challenge-card-content-left {
- flex: 1;
- display: flex;
- flex-direction: row;
- justify-content: flex-start;
- align-items: center;
- width: inherit;
- .challenge-card-content-badge {
- height: 4.5rem;
- width: 4.5rem;
- }
- .challenge-card-content-title {
- margin-left: 1rem;
- color: $white;
- }
- }
- .challenge-card-content-right {
- display: flex;
- flex-direction: row;
- justify-content: center;
- align-items: center;
- align-self: center;
- }
-}
\ No newline at end of file
diff --git a/src/components/Report/challengereport.scss b/src/components/Report/challengereport.scss
deleted file mode 100644
index fe485d3f382f769b669a47e000ff8efc3a1568a3..0000000000000000000000000000000000000000
--- a/src/components/Report/challengereport.scss
+++ /dev/null
@@ -1,40 +0,0 @@
-@import '../../styles/base/color';
-@import '../../styles/base/breakpoint';
-
-
-.challenge-root {
- margin-bottom: 1rem;
- .challenge-card-link {
- color: black;
- text-decoration: none;
- }
- .challenge-card {
- cursor: pointer;
- display: flex;
- flex-direction: row;
- width: 100%;
- .challenge-card-content-left {
- flex: 1;
- display: flex;
- flex-direction: row;
- justify-content: flex-start;
- align-items: center;
- width: inherit;
- .challenge-card-content-badge {
- height: 4.5rem;
- width: 4.5rem;
- }
- .challenge-card-content-title {
- margin-left: 1rem;
- color: $white;
- }
- }
- .challenge-card-content-right {
- display: flex;
- flex-direction: row;
- justify-content: center;
- align-items: center;
- align-self: center;
- }
- }
-}
\ No newline at end of file
diff --git a/src/components/Routes/Routes.tsx b/src/components/Routes/Routes.tsx
index 386bdd32346af80c06d31330d0643980e9c224c0..ec47e91cc2a72d4cdc94e6481841d809fb5687b5 100644
--- a/src/components/Routes/Routes.tsx
+++ b/src/components/Routes/Routes.tsx
@@ -7,19 +7,7 @@ const HomeView = lazy(() => import('components/Home/HomeView'))
const SingleFluidView = lazy(() =>
import('components/SingleFluid/SingleFluidView')
)
-const ChallengeView = lazy(() => import('components/Challenge/ChallengeView'))
-const LockedChallengeDetailsViewContainer = lazy(() =>
- import('components/Challenge/LockedChallengeDetailsViewContainer')
-)
-const AvailableChallengeDetailsView = lazy(() =>
- import('components/Challenge/AvailableChallengeDetailsView')
-)
-const OngoingChallengeDetailsView = lazy(() =>
- import('components/Challenge/OngoingChallengeDetailsView')
-)
-const FinishedChallengeDetailsView = lazy(() =>
- import('components/Challenge/FinishedChallengeDetailsView')
-)
+
const EcogestureView = lazy(() =>
import('components/Ecogesture/EcogestureView')
)
@@ -64,22 +52,6 @@ const Routes = () => {
path="/challenges"
render={({ match: { url } }) => (
<>
- <Route
- path={`${url}/locked`}
- component={LockedChallengeDetailsViewContainer}
- />
- <Route
- path={`${url}/available`}
- component={AvailableChallengeDetailsView}
- />
- <Route
- path={`${url}/ongoing`}
- component={OngoingChallengeDetailsView}
- />
- <Route
- path={`${url}/finished`}
- component={FinishedChallengeDetailsView}
- />
<Route path={`${url}/`} component={SeasonView} exact />
</>
)}
diff --git a/src/components/Splash/SplashRoot.tsx b/src/components/Splash/SplashRoot.tsx
index 54c2745be2b9b4fee29171f979601f444cf8e61e..b1e122f2d535cbfe70f2990d5d664a0db3a24c82 100644
--- a/src/components/Splash/SplashRoot.tsx
+++ b/src/components/Splash/SplashRoot.tsx
@@ -1,13 +1,13 @@
import React, { useState, useEffect, ComponentType, ReactNode } from 'react'
import { useClient } from 'cozy-client'
-import { useSetRecoilState } from 'recoil'
import classNames from 'classnames'
+import { useDispatch } from 'react-redux'
+import { toogleReportNotification } from 'store/global/global.actions'
+import { updateProfile } from 'store/profile/profile.actions'
+import { useSetRecoilState } from 'recoil'
import { fluidStatusState } from 'atoms/fluidState.state'
import { userProfileState } from 'atoms/userProfile.state'
-import { currentChallengeState } from 'atoms/challenge.state'
-import { challengeNotificationState } from 'atoms/notification.state'
import InitializationService from 'services/initialization.service'
-import { getActualReportDate } from 'utils/date'
interface SplashRootProps {
fadeTimer?: number
@@ -32,12 +32,8 @@ const SplashRoot = ({
splashStart: false,
})
const [error, setError] = useState<Error | null>(null)
- const setUserProfile = useSetRecoilState(userProfileState)
+ const dispatch = useDispatch()
const setFluidStatusState = useSetRecoilState(fluidStatusState)
- const setCurrentChallengeState = useSetRecoilState(currentChallengeState)
- const setChallengeNotificationState = useSetRecoilState(
- challengeNotificationState
- )
const initializationService = new InitializationService(client)
@@ -55,53 +51,37 @@ const SplashRoot = ({
let subscribed = true
async function loadData() {
try {
- await initializationService.initIndex()
- let profile = await initializationService.initUserProfile()
+ // Init index
+ // await initializationService.initIndex()
+ // Init profile and update ecogestures, seasons, report
+ let profile = await initializationService.initProfile()
if (subscribed && profile) {
- const resultChallengeType = await initializationService.initChallengeType(
- profile.challengeTypeHash
- )
- if (
- subscribed &&
- resultChallengeType.result &&
- resultChallengeType.userProfile
- ) {
- profile = resultChallengeType.userProfile
- }
const resultEcogesture = await initializationService.initEcogesture(
profile.ecogestureHash
)
if (
subscribed &&
resultEcogesture.result &&
- resultEcogesture.userProfile
+ resultEcogesture.profile
) {
- profile = resultEcogesture.userProfile
- }
-
- const resultReport = await initializationService.initReport(
- profile.report
- )
- if (subscribed && resultReport.result && resultReport.userProfile) {
- profile = resultReport.userProfile
+ profile = resultEcogesture.profile
}
- setUserProfile(profile)
- await initializationService.initUserChallenge()
- const fluidStatus = await initializationService.initFluidStatus()
- setFluidStatusState(fluidStatus)
- const currentChallenge = await initializationService.initCurrentChallenge()
- if (currentChallenge) {
- setCurrentChallengeState(currentChallenge)
- const isChallengeOver = await initializationService.isCurrentChallengeOver(
- currentChallenge
- )
- setChallengeNotificationState(isChallengeOver)
+ // TODO add initSeasons
+ const resultReport = await initializationService.initReport(profile)
+ if (subscribed && resultReport.result && resultReport.profile) {
+ profile = resultReport.profile
}
- setState(prev => ({
- ...prev,
- splashStart: true,
- }))
+ dispatch(updateProfile(profile))
+ dispatch(toogleReportNotification(!profile.haveSeenLastReport))
}
+ // Init Fluid status
+ const fluidStatus = await initializationService.initFluidStatus()
+ setFluidStatusState(fluidStatus)
+ // Update state
+ setState(prev => ({
+ ...prev,
+ splashStart: true,
+ }))
} catch (err) {
setError(err)
}
diff --git a/src/db/challengeTypeData.json b/src/db/challengeTypeData.json
deleted file mode 100644
index 2be594a8afa18b8e2374bd1d4da99c5406969d21..0000000000000000000000000000000000000000
--- a/src/db/challengeTypeData.json
+++ /dev/null
@@ -1,135 +0,0 @@
-[
- {
- "_id": "CHA00000001",
- "type": 1,
- "title": "Ecolyo Royal",
- "description": "Connecter l'application Ecolyo à un distributeur d'énergie",
- "level": 1,
- "duration": { "days": 0 },
- "fluidTypes": [0, 1, 2],
- "relationships": {
- "availableEcogestures": {
- "data": [
- { "_id": "0085", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0092", "_type": "com.grandlyon.ecolyo.ecogesture" }
- ]
- }
- }
- },
- {
- "_id": "CHA00000002",
- "type": 0,
- "title": "Coques en stock",
- "description": "Et si dans les 7 prochains jours vous réussissiez à consommer moins que dans les 7 derniers ?",
- "level": 2,
- "duration": { "days": 7 },
- "fluidTypes": [0, 1, 2],
- "relationships": {
- "availableEcogestures": {
- "data": [
- { "_id": "0032", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0034", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0041", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0042", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0043", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0045", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0050", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0058", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0064", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0066", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0071", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0078", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0082", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0093", "_type": "com.grandlyon.ecolyo.ecogesture" }
- ]
- }
- }
- },
- {
- "_id": "CHA00000003",
- "type": 0,
- "title": "Méga Coques en stock",
- "description": "Et si dans les 4 prochaines semaines vous réussissiez à consommer moins que dans les 4 dernières ?",
- "level": 3,
- "duration": { "days": 28 },
- "fluidTypes": [0, 1, 2],
- "relationships": {
- "availableEcogestures": {
- "data": [
- { "_id": "0032", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0034", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0041", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0042", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0043", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0045", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0050", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0058", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0064", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0066", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0071", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0078", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0082", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0093", "_type": "com.grandlyon.ecolyo.ecogesture" }
- ]
- }
- }
- },
- {
- "_id": "CHA00000004",
- "type": 0,
- "title": "Winter is leaving",
- "description": "Et si dans les 7 prochains jours vous réussissiez à consommer moins que dans les 7 derniers",
- "level": 901,
- "duration": { "days": 7 },
- "fluidTypes": [0, 1, 2],
- "relationships": {
- "availableEcogestures": {
- "data": [
- { "_id": "0032", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0034", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0041", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0042", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0043", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0045", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0050", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0058", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0064", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0066", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0071", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0078", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0082", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0093", "_type": "com.grandlyon.ecolyo.ecogesture" }
- ]
- }
- }
- },
- {
- "_id": "CHA00000005",
- "type": 0,
- "title": "Méga Winter is leaving",
- "description": "Et si dans les 7 prochains jours vous réussissiez à consommer moins que dans les 7 derniers",
- "level": 902,
- "duration": { "days": 7 },
- "fluidTypes": [0, 1, 2],
- "relationships": {
- "availableEcogestures": {
- "data": [
- { "_id": "0032", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0034", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0041", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0042", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0043", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0045", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0050", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0058", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0064", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0066", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0071", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0078", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0082", "_type": "com.grandlyon.ecolyo.ecogesture" },
- { "_id": "0093", "_type": "com.grandlyon.ecolyo.ecogesture" }
- ]
- }
- }
- }
-]
diff --git a/src/db/profileData.json b/src/db/profileData.json
new file mode 100644
index 0000000000000000000000000000000000000000..2c1f724cba15bf6da77ccdca13077ef754ffac45
--- /dev/null
+++ b/src/db/profileData.json
@@ -0,0 +1,12 @@
+[
+ {
+ "challengeTypeHash": "",
+ "ecogestureHash": "",
+ "isFirstConnection": true,
+ "haveSeenFavoriteModal": false,
+ "haveSeenOldFluidModal": false,
+ "haveSeenLastReport": true,
+ "sendReportNotification": false,
+ "monthlyReportDate": "0000-01-01T00:00:00.000Z"
+ }
+]
diff --git a/src/db/userChallengeData.json b/src/db/userChallengeData.json
deleted file mode 100644
index 374af7e673198732d20fddba168f2cd51348681d..0000000000000000000000000000000000000000
--- a/src/db/userChallengeData.json
+++ /dev/null
@@ -1,29 +0,0 @@
-[
- {
- "startingDate": "0001-01-01T00:00:00.000Z",
- "endingDate": "9999-01-01T00:00:00.000Z",
- "state": 0,
- "maxEnergy": -1,
- "currentEnergy": -1,
- "relationships": {
- "challengeType": {
- "data": {
- "_id": "CHA00000001",
- "_type": "com.grandlyon.ecolyo.challengetype"
- }
- },
- "selectedEcogestures": {
- "data": [
- {
- "_id": "0085",
- "_type": "com.grandlyon.ecolyo.ecogesture"
- },
- {
- "_id": "0092",
- "_type": "com.grandlyon.ecolyo.ecogesture"
- }
- ]
- }
- }
- }
-]
diff --git a/src/db/userProfileData.json b/src/db/userProfileData.json
deleted file mode 100644
index 5ed06d03662c7c3d2882cb975258a3bde259f285..0000000000000000000000000000000000000000
--- a/src/db/userProfileData.json
+++ /dev/null
@@ -1,16 +0,0 @@
-[
- {
- "level": 1,
- "challengeTypeHash": "",
- "ecogestureHash": "",
- "haveSeenFavoriteModal": false,
- "isFirstConnection": true,
- "haveSeenOldFluidModal": false,
- "notificationEcogesture": ["0085", "0092"],
- "report": {
- "sendReportNotification": false,
- "haveSeenLastReport": true,
- "monthlyReportDate": "0000-01-01T00:00:00.000Z"
- }
- }
-]
diff --git a/src/doctypes/com-grandlyon-ecolyo-challengetype.ts b/src/doctypes/com-grandlyon-ecolyo-challengetype.ts
deleted file mode 100644
index fb4644f51a9e754d159f5b8e708d721ab3e942bf..0000000000000000000000000000000000000000
--- a/src/doctypes/com-grandlyon-ecolyo-challengetype.ts
+++ /dev/null
@@ -1 +0,0 @@
-export const CHALLENGETYPE_DOCTYPE = 'com.grandlyon.ecolyo.challengetype'
diff --git a/src/doctypes/com-grandlyon-ecolyo-profile.ts b/src/doctypes/com-grandlyon-ecolyo-profile.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b68bb827fc5d49daea0890dd3a097bbde7fd9f0c
--- /dev/null
+++ b/src/doctypes/com-grandlyon-ecolyo-profile.ts
@@ -0,0 +1 @@
+export const PROFILE_DOCTYPE = 'com.grandlyon.ecolyo.profile'
diff --git a/src/doctypes/com-grandlyon-ecolyo-userchallenge.ts b/src/doctypes/com-grandlyon-ecolyo-userchallenge.ts
deleted file mode 100644
index d9e45fded19d3dc3cd60cd8cb949f292346679dd..0000000000000000000000000000000000000000
--- a/src/doctypes/com-grandlyon-ecolyo-userchallenge.ts
+++ /dev/null
@@ -1 +0,0 @@
-export const USERCHALLENGE_DOCTYPE = 'com.grandlyon.ecolyo.userchallenge'
diff --git a/src/doctypes/com-grandlyon-ecolyo-userprofile.ts b/src/doctypes/com-grandlyon-ecolyo-userprofile.ts
deleted file mode 100644
index 4f24412b255f074cffc2adf29933874f5fa1ed81..0000000000000000000000000000000000000000
--- a/src/doctypes/com-grandlyon-ecolyo-userprofile.ts
+++ /dev/null
@@ -1 +0,0 @@
-export const USERPROFILE_DOCTYPE = 'com.grandlyon.ecolyo.userprofile'
diff --git a/src/doctypes/index.ts b/src/doctypes/index.ts
index 07e0993b95e2278f74dfb24acb326dcfd6c35282..b144eb622874e4f5141b80383cc3113f335eae63 100644
--- a/src/doctypes/index.ts
+++ b/src/doctypes/index.ts
@@ -6,10 +6,8 @@ import { KONNECTORS_DOCTYPE } from './io-cozy-konnectors'
import { ACCOUNTS_DOCTYPE } from './io-cozy-accounts'
import { JOBS_DOCTYPE } from './io-cozy-jobs'
-import { CHALLENGETYPE_DOCTYPE } from './com-grandlyon-ecolyo-challengetype'
-import { USERCHALLENGE_DOCTYPE } from './com-grandlyon-ecolyo-userchallenge'
import { ECOGESTURE_DOCTYPE } from './com-grandlyon-ecolyo-ecogesture'
-import { USERPROFILE_DOCTYPE } from './com-grandlyon-ecolyo-userprofile'
+import { PROFILE_DOCTYPE } from './com-grandlyon-ecolyo-profile'
// the documents schema, necessary for CozyClient
const doctypes = {
@@ -43,37 +41,13 @@ const doctypes = {
attributes: {},
relationships: {},
},
- challengetype: {
- doctype: CHALLENGETYPE_DOCTYPE,
- attributes: {},
- relationships: {
- availableEcogestures: {
- doctype: ECOGESTURE_DOCTYPE,
- type: 'has-many',
- },
- },
- },
- userchallenge: {
- doctype: USERCHALLENGE_DOCTYPE,
- attributes: {},
- relationships: {
- selectedEcogestures: {
- doctype: ECOGESTURE_DOCTYPE,
- type: 'has-many',
- },
- challengeType: {
- doctype: CHALLENGETYPE_DOCTYPE,
- type: 'has-one',
- },
- },
- },
ecogesture: {
doctype: ECOGESTURE_DOCTYPE,
attributes: {},
relationships: {},
},
- userprofile: {
- doctype: USERPROFILE_DOCTYPE,
+ profile: {
+ doctype: PROFILE_DOCTYPE,
attributes: {},
relationships: {},
},
@@ -102,7 +76,5 @@ export * from './io-cozy-accounts'
export * from './io-cozy-triggers'
export * from './io-cozy-jobs'
-export * from './com-grandlyon-ecolyo-challengetype'
-export * from './com-grandlyon-ecolyo-userchallenge'
export * from './com-grandlyon-ecolyo-ecogesture'
-export * from './com-grandlyon-ecolyo-userprofile'
+export * from './com-grandlyon-ecolyo-profile'
diff --git a/src/models/challenge.model.ts b/src/models/challenge.model.ts
deleted file mode 100644
index 7306de6fb21d528d2e29e188e4e16ba40a52e460..0000000000000000000000000000000000000000
--- a/src/models/challenge.model.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { DateTime, Duration } from 'luxon'
-import { FluidType } from 'enum/fluid.enum'
-import { BadgeState, ChallengeState, TypeChallenge } from 'enum/challenge.enum'
-import { Ecogesture } from './ecogesture.model'
-
-export interface ChallengeType {
- id: string
- type: TypeChallenge
- title: string
- description: string
- level: number
- duration: Duration
- fluidTypes: FluidType[]
- availableEcogestures: Ecogesture[]
-}
-
-export interface UserChallenge {
- id?: string
- startingDate: DateTime
- endingDate: DateTime
- state: ChallengeState
- selectedEcogestures: Ecogesture[]
- challengeType: ChallengeType | null
- maxEnergy: number
- currentEnergy: number
- badge: BadgeState | null
- fluidTypes: FluidType[]
-}
diff --git a/src/models/global.model.ts b/src/models/global.model.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0dddf2c336b2720d60476c1c66fecea2233320ca
--- /dev/null
+++ b/src/models/global.model.ts
@@ -0,0 +1,7 @@
+import { ScreenType } from 'enum/screen.enum'
+
+export interface GlobalState {
+ screenType: ScreenType
+ seasonNotification: boolean
+ reportNotification: boolean
+}
diff --git a/src/models/index.ts b/src/models/index.ts
index 5cd40965db4009822d828c0e2e4c5159c1658f7a..9260f60bd223e30a149c6a20f1d2907b4285dcff 100644
--- a/src/models/index.ts
+++ b/src/models/index.ts
@@ -5,9 +5,11 @@ export * from './datachart.model'
export * from './dataload.model'
export * from './ecogesture.model'
export * from './fluid.model'
+export * from './global.model'
export * from './indicator.model'
export * from './konnector.model'
export * from './modal.model'
+export * from './profile.model'
export * from './report.model'
export * from './timePeriod.model'
export * from './trigger.model'
diff --git a/src/models/userProfile.model.ts b/src/models/profile.model.ts
similarity index 56%
rename from src/models/userProfile.model.ts
rename to src/models/profile.model.ts
index 237cc7541c3c5263d40e74f01ffc79b6b5ed4b7a..5a02cd63311a652b2945724727cae01817450104 100644
--- a/src/models/userProfile.model.ts
+++ b/src/models/profile.model.ts
@@ -1,14 +1,15 @@
import { DateTime } from 'luxon'
-import { ReportAttributes } from './report.model'
-export interface UserProfile {
+export interface Profile {
id: string
- level: number
challengeTypeHash: string
ecogestureHash: string
- haveSeenFavoriteModal: boolean
isFirstConnection: boolean
+ haveSeenFavoriteModal: boolean
+ haveSeenLastReport: boolean
haveSeenOldFluidModal: DateTime | boolean
- notificationEcogesture: string[]
- report: ReportAttributes
+ sendReportNotification: boolean
+ monthlyReportDate: DateTime
+ _id?: string
+ _rev?: string
}
diff --git a/src/services/challenge.service.ts b/src/services/challenge.service.ts
deleted file mode 100644
index 16bb0f4d4cf40eb68cae8bc30707e24965bf2547..0000000000000000000000000000000000000000
--- a/src/services/challenge.service.ts
+++ /dev/null
@@ -1,761 +0,0 @@
-import { DateTime } from 'luxon'
-import { Client } from 'cozy-client'
-
-import {
- CHALLENGETYPE_DOCTYPE,
- ECOGESTURE_DOCTYPE,
- USERCHALLENGE_DOCTYPE,
-} from 'doctypes'
-
-import UserProfileService from 'services/userProfile.service'
-import ChallengeMapperService, {
- UserChallengeEntity,
- ChallengeTypeEntity,
-} from 'services/challengeMapper.service'
-import { FluidType } from 'enum/fluid.enum'
-import { ChallengeState, TypeChallenge, BadgeState } from 'enum/challenge.enum'
-import { TimeStep } from 'enum/timeStep.enum'
-import { Ecogesture, UserProfile, UserChallenge, ChallengeType } from 'models'
-import ConsumptionService from 'services/consumption.service'
-import PerformanceIndicatorService from 'services/performanceIndicator.service'
-import { getCompareChallengePeriod, getLagDays } from 'utils/date'
-
-export default class ChallengeService {
- private readonly _client: Client
- private readonly _challengeMapper: ChallengeMapperService
-
- constructor(_client: Client) {
- this._client = _client
- this._challengeMapper = new ChallengeMapperService()
- }
-
- public async updateChallenge(
- id: string | undefined,
- attributes: {
- [key: string]: string | boolean | number | ChallengeState
- }
- ): Promise<UserChallenge | null> {
- try {
- const { data: userchallenge } = await this._client
- .query(
- this._client
- .find(USERCHALLENGE_DOCTYPE)
- .where({ _id: id })
- .limitBy(1)
- )
- .then(async ({ data }: any) => {
- const doc = data[0]
- return await this._client.save({
- ...doc,
- ...attributes,
- })
- })
- return userchallenge ? userchallenge : null
- } catch (err) {
- console.log(err)
- throw err
- }
- }
-
- public async getMaxEnergy(
- challenge: UserChallenge,
- challengeFluidTypes: FluidType[]
- ): Promise<number> {
- const period = getCompareChallengePeriod(challenge, challengeFluidTypes)
- try {
- if (challenge && challenge.challengeType) {
- const consumptionService = new ConsumptionService(this._client)
- const fetchedPerformanceIndicators = await consumptionService.getPerformanceIndicators(
- period,
- TimeStep.DAY,
- challengeFluidTypes
- )
- const performanceIndicatorService = new PerformanceIndicatorService()
- const maxEnergy = performanceIndicatorService.aggregatePerformanceIndicators(
- fetchedPerformanceIndicators
- )
- if (maxEnergy && maxEnergy.value && maxEnergy.value > 0) {
- return maxEnergy.value
- }
- }
- return -1
- } catch (error) {
- console.log(error)
- return -1
- }
- }
-
- public async setMaxEnergy(
- challenge: UserChallenge,
- challengeFluidTypes: FluidType[]
- ): Promise<number> {
- const maxEnergy = await this.getMaxEnergy(challenge, challengeFluidTypes)
- if (maxEnergy && maxEnergy > 0) {
- try {
- await this.updateChallenge(challenge.id, {
- maxEnergy: maxEnergy,
- })
- return maxEnergy
- } catch (error) {
- console.log(error)
- return -1
- }
- }
- return -1
- }
-
- public async getSpentEnergy(
- challenge: UserChallenge,
- challengeFluidTypes: FluidType[]
- ): Promise<number> {
- const lagDays = getLagDays(challengeFluidTypes)
- if (DateTime.local() > challenge.startingDate.plus({ days: lagDays })) {
- const consumptionService = new ConsumptionService(this._client)
- const startDate = challenge.startingDate
- let endDate = DateTime.local()
- .plus({ days: -lagDays })
- .endOf('day')
- if (await this.isChallengeOver(challenge, challengeFluidTypes)) {
- endDate = challenge.endingDate.plus({ days: -1 }).endOf('day')
- }
- const period = { startDate, endDate }
- try {
- if (challenge && challenge.challengeType) {
- const fetchedPerformanceIndicators = await consumptionService.getPerformanceIndicators(
- period,
- TimeStep.DAY,
- challengeFluidTypes
- )
- const performanceIndicatorService = new PerformanceIndicatorService()
- const spentEnergy = performanceIndicatorService.aggregatePerformanceIndicators(
- fetchedPerformanceIndicators
- )
- if (spentEnergy && spentEnergy.value && spentEnergy.value >= 0) {
- return spentEnergy.value
- }
- }
- } catch (error) {
- console.log(error)
- return 0
- }
- }
- return 0
- }
-
- public async setSpentEnergy(
- challenge: UserChallenge,
- challengeFluidTypes: FluidType[]
- ): Promise<number> {
- const spentEnergy = await this.getSpentEnergy(
- challenge,
- challengeFluidTypes
- )
- if (spentEnergy && spentEnergy >= 0) {
- try {
- await this.updateChallenge(challenge.id, {
- currentEnergy: spentEnergy,
- })
-
- return spentEnergy
- } catch (error) {
- console.log(error)
- return 0
- }
- }
- return 0
- }
-
- public async isChallengeOver(
- challenge: UserChallenge,
- fluidTypes: FluidType[]
- ) {
- if (challenge) {
- const typeChallenge = challenge.challengeType
- ? challenge.challengeType.type
- : 0
- return this.isChallengeOverByDate(
- challenge.endingDate,
- fluidTypes,
- typeChallenge
- )
- } else {
- return false
- }
- }
-
- public async isChallengeOverByDate(
- endingDate: DateTime,
- fluidTypes: FluidType[],
- typeChallenge: TypeChallenge
- ) {
- const lagDays = getLagDays(fluidTypes)
- const endDate =
- typeChallenge === TypeChallenge.CHALLENGE
- ? endingDate.plus({ days: lagDays - 1 }).startOf('day')
- : endingDate
- if (DateTime.local() > endDate) {
- return true
- } else {
- return false
- }
- }
-
- public getTheRightBadge(
- spentEnergy: number | null,
- maxEnergy: number | null
- ) {
- if (spentEnergy && maxEnergy) {
- if (spentEnergy < maxEnergy) {
- return 1
- } else {
- return 0
- }
- }
- }
-
- public async setTheRightBadge(challenge: UserChallenge): Promise<boolean> {
- let badge: BadgeState | null = null
- if (challenge.challengeType) {
- if (challenge.challengeType.type === 0) {
- badge =
- challenge.currentEnergy < challenge.maxEnergy
- ? BadgeState.SUCCESS
- : BadgeState.FAILED
- } else if (challenge.challengeType.type === 1) {
- badge = BadgeState.SUCCESS
- }
- try {
- await this._client
- .query(
- this._client
- .find(USERCHALLENGE_DOCTYPE)
- .where({ _id: challenge.id })
- .limitBy(1)
- )
- .then(async ({ data }) => {
- const doc = data[0]
- await this._client.save({
- ...doc,
- badge: badge,
- })
- })
- return true
- } catch (error) {
- return false
- }
- }
- return false
- }
-
- public async endChallenge(
- challenge: UserChallenge,
- fluidTypes: FluidType[]
- ): Promise<boolean> {
- try {
- if (challenge && challenge.challengeType) {
- if (await this.isChallengeOver(challenge, fluidTypes)) {
- if (challenge.challengeType.type === TypeChallenge.ACHIEVEMENT) {
- await this.updateChallenge(challenge.id, {
- state: ChallengeState.FINISHED,
- })
- const userProfileService = new UserProfileService(this._client)
- await userProfileService.updateUserProfile({
- level: challenge.challengeType.level + 1,
- })
- } else {
- if (
- this.getTheRightBadge(
- challenge.currentEnergy,
- challenge.maxEnergy
- )
- ) {
- const userProfileService = new UserProfileService(this._client)
- await userProfileService.updateUserProfile({
- level: challenge.challengeType.level + 1,
- })
- }
- await this.updateChallenge(challenge.id, {
- state: ChallengeState.FINISHED,
- })
- }
- }
- }
- return true
- } catch (err) {
- console.log(err)
- throw err
- }
- }
-
- /*
- * Return the date of the first day for which
- * we can calculate the data in function of configured fluidTypes
- */
- public getViewingDate = (challenge: UserChallenge): DateTime => {
- const startingDate = challenge.startingDate
- if (challenge && challenge.fluidTypes && challenge.fluidTypes.length > 0) {
- const lagDays = getLagDays(challenge.fluidTypes)
- return startingDate.plus({ days: lagDays })
- } else {
- return startingDate
- }
- }
-
- public async getAllChallengeTypeEntities(): Promise<
- ChallengeTypeEntity[] | null
- > {
- let challengeTypeEntities: ChallengeTypeEntity[] | null = null
-
- const challengeTypesresult = await this._client.query(
- this._client.find(CHALLENGETYPE_DOCTYPE)
- )
- challengeTypeEntities = challengeTypesresult.data
- ? challengeTypesresult.data
- : null
-
- if (!challengeTypeEntities) return null
-
- return challengeTypeEntities
- }
-
- public async deleteAllChallengeTypeEntities(): Promise<boolean> {
- try {
- const challengeType = await this.getAllChallengeTypeEntities()
- if (!challengeType) return true
- for (let index = 0; index < challengeType.length; index++) {
- await this._client.destroy(challengeType[index])
- }
- return true
- } catch (err) {
- console.log(err)
- throw err
- }
- }
-
- public async getAvailableChallenges(
- fluidTypes?: FluidType[]
- ): Promise<ChallengeType[] | null> {
- const userProfileService = new UserProfileService(this._client)
- const userProfile: UserProfile | null = await userProfileService.getUserProfile()
-
- if (fluidTypes && fluidTypes.length === 0) {
- fluidTypes = [0, 1, 2]
- }
-
- if (!userProfile) return null
- const predicate = this.getAvailableChallengesPredicate(
- fluidTypes,
- userProfile && userProfile.level
- )
-
- const challengeTypesresult = await this._client.query(
- this._client
- .find(CHALLENGETYPE_DOCTYPE)
- .where(predicate)
- .include(['availableEcogestures'])
- .sortBy([{ level: 'desc' }])
- )
-
- const challengeTypeEntities:
- | ChallengeTypeEntity[]
- | null = challengeTypesresult.data ? challengeTypesresult.data : null
-
- const challengeTypeEntityRelationships:
- | object
- | null = challengeTypesresult.included
- ? challengeTypesresult.included
- : null
-
- if (!challengeTypeEntities || challengeTypeEntities.length === 0)
- return null
- const unlockedEcogestures = await this.getUnlockedEcogestures()
- const challengeTypes = this._challengeMapper.mapToChallengeTypes(
- challengeTypeEntities,
- challengeTypeEntityRelationships,
- unlockedEcogestures || undefined
- // fluidTypes
- )
- return challengeTypes
- }
-
- public async updateCurrentChallengeProgress(
- challenge: UserChallenge
- ): Promise<UserChallenge | null> {
- try {
- if (
- challenge &&
- challenge.challengeType &&
- challenge.challengeType.type === TypeChallenge.CHALLENGE
- ) {
- if (challenge.maxEnergy === -1 && challenge.fluidTypes) {
- const maxEnergyResult = await this.setMaxEnergy(
- challenge,
- challenge.fluidTypes
- )
- if (maxEnergyResult > 0) {
- challenge.maxEnergy = maxEnergyResult
- }
- }
- // Check if we are in the viewing timezone for current challenge
- const viewingDate = this.getViewingDate(challenge)
- if (DateTime.local() >= viewingDate && challenge.fluidTypes) {
- const currentEnergyResult = await this.setSpentEnergy(
- challenge,
- challenge.fluidTypes
- )
- if (currentEnergyResult) {
- challenge.currentEnergy = currentEnergyResult
- }
- }
- }
- return challenge
- } catch (error) {
- console.log('Context error: ', error)
- throw error
- }
- }
-
- public async startChallenge(
- challenge: ChallengeType,
- fluidTypes: FluidType[],
- selectedEcogestes: Ecogesture[]
- ): Promise<UserChallenge | null> {
- try {
- // Ensure that none challenge is already on going
- const ongoingChallenge = await this.getCurrentChallenge()
- if (!ongoingChallenge) {
- const startDate = DateTime.utc().startOf('day')
-
- const userChallenge: UserChallenge = {
- startingDate: startDate,
- endingDate: startDate.plus(challenge.duration),
- state: ChallengeState.ONGOING,
- selectedEcogestures: selectedEcogestes,
- challengeType: challenge,
- maxEnergy: -1,
- currentEnergy: -1,
- badge: -1,
- fluidTypes: fluidTypes,
- }
-
- await this._client.create(
- USERCHALLENGE_DOCTYPE,
- this._challengeMapper.mapFromUserChallenge(userChallenge)
- )
-
- // Retrive the challenge from base to have the userChallengeEntityRelationships
- let createdUserChallenge = await this.getCurrentChallenge()
- if (createdUserChallenge) {
- // Update challenge progess
- createdUserChallenge = await this.updateCurrentChallengeProgress(
- createdUserChallenge
- )
- }
- return createdUserChallenge
- } else {
- return null
- }
- } catch (err) {
- console.log(err)
- throw err
- }
- }
-
- public async getAllUserChallenges(
- withEcogestures = true
- ): Promise<UserChallenge[] | null> {
- const relationShipsToInclude = ['challengeType']
- if (withEcogestures) relationShipsToInclude.push('selectedEcogestures')
-
- const resultUserChallenge = await this._client.query(
- this._client
- .find(USERCHALLENGE_DOCTYPE)
- .include(relationShipsToInclude)
- .where({
- state: {
- $gte: ChallengeState.ONGOING,
- $lt: ChallengeState.ABANDONED,
- },
- })
- .sortBy([{ endingDate: 'desc' }])
- )
-
- if (resultUserChallenge && !resultUserChallenge.data[0]) {
- return []
- }
-
- const userChallengeEntitites:
- | UserChallengeEntity[]
- | null = resultUserChallenge.data ? resultUserChallenge.data : null
-
- const userChallengeEntityRelationships:
- | object
- | null = resultUserChallenge.included
- ? resultUserChallenge.included
- : null
-
- if (!userChallengeEntitites || userChallengeEntitites.length === 0)
- return null
- const userChallenges: UserChallenge[] = []
-
- userChallengeEntitites.forEach(userChallengeEntitity => {
- userChallenges.push(
- this._challengeMapper.mapToUserChallenge(
- userChallengeEntitity,
- userChallengeEntityRelationships
- )
- )
- })
-
- return userChallenges
- }
-
- public async getFinishedUserChallengesOnMonth(
- date: DateTime
- ): Promise<UserChallenge[]> {
- try {
- const startDate = date.startOf('month')
- const endDate = date.endOf('month')
- const resultUserChallenge = await this._client.query(
- this._client
- .find(USERCHALLENGE_DOCTYPE)
- .include(['challengeType', 'selectedEcogestures'])
- .where({
- state: {
- $eq: ChallengeState.FINISHED,
- },
- endingDate: {
- $gte: startDate.toISO(),
- $lte: endDate.toISO(),
- },
- })
- .sortBy([{ endingDate: 'desc' }])
- )
-
- if (resultUserChallenge && !resultUserChallenge.data[0]) {
- return []
- }
-
- const userChallengeEntitites:
- | UserChallengeEntity[]
- | null = resultUserChallenge.data ? resultUserChallenge.data : null
-
- const userChallengeEntityRelationships:
- | object
- | null = resultUserChallenge.included
- ? resultUserChallenge.included
- : null
-
- if (!userChallengeEntitites || userChallengeEntitites.length === 0)
- return []
- const userChallenges: UserChallenge[] = []
-
- userChallengeEntitites.forEach(userChallengeEntitity => {
- userChallenges.push(
- this._challengeMapper.mapToUserChallenge(
- userChallengeEntitity,
- userChallengeEntityRelationships
- )
- )
- })
- return userChallenges
- } catch (error) {
- console.log(error)
- throw error
- }
- }
-
- public async getCurrentChallenge(
- withEcogestures = true
- ): Promise<UserChallenge | null> {
- const relationShipsToInclude = ['challengeType']
- if (withEcogestures) relationShipsToInclude.push('selectedEcogestures')
-
- const resultUserChallenge = await this._client.query(
- this._client
- .find(USERCHALLENGE_DOCTYPE)
- .where({
- state: {
- $eq: ChallengeState.ONGOING,
- },
- })
- .include(relationShipsToInclude)
- .limitBy(1)
- )
-
- const userChallengeEntitites:
- | UserChallengeEntity[]
- | null = resultUserChallenge.data ? resultUserChallenge.data : null
-
- const userChallengeEntityRelationships:
- | object
- | null = resultUserChallenge.included
- ? resultUserChallenge.included
- : null
-
- if (!userChallengeEntitites || userChallengeEntitites.length === 0)
- return null
-
- const userChallenge = this._challengeMapper.mapToUserChallenge(
- userChallengeEntitites[0],
- userChallengeEntityRelationships
- )
- return userChallenge
- }
-
- public async cancelChallenge(id: string): Promise<boolean> {
- try {
- await this.updateChallenge(id, {
- state: ChallengeState.ABANDONED,
- })
- return true
- } catch (err) {
- console.log(err)
- throw err
- }
- }
-
- public async getUnlockedEcogestures(): Promise<string[] | null> {
- const relationShipsToInclude = ['selectedEcogestures']
- const ecogestures = await this._client.query(
- this._client
- .find(USERCHALLENGE_DOCTYPE)
- .where({
- state: {
- $lte: ChallengeState.FINISHED,
- },
- })
- .include(relationShipsToInclude)
- )
- if (ecogestures.data.length === 0) return null
- const unlocked = ecogestures.data.map(
- x => x.relationships.selectedEcogestures.data
- )
-
- return unlocked.flat().map(eg => eg._id)
- }
-
- public async getAllEcogestures(): Promise<Ecogesture[] | null> {
- const ecogestures = await this._client.query(
- this._client.find(ECOGESTURE_DOCTYPE)
- )
- if (!ecogestures) return null
-
- return ecogestures.data
- }
-
- public getAvailableChallengesPredicate(
- fluidTypes?: FluidType[],
- level?: number
- ) {
- let predicate = {}
-
- let fluidTypePredicate = {}
- // the predicate changes if the fluidType Array has more than 1 element
- if (fluidTypes) {
- if (fluidTypes.length >= 2) {
- const orClauses: any = []
- fluidTypes.forEach(fluidType =>
- orClauses.push({
- $elemMatch: {
- $eq: fluidType,
- },
- })
- )
- fluidTypePredicate = { $or: [...orClauses] }
- } else if (fluidTypes.length == 1) {
- fluidTypePredicate = {
- $elemMatch: {
- $eq: fluidTypes[0],
- },
- }
- }
- }
-
- let levelPredicate = {}
- if (level) {
- levelPredicate = {
- $gte: level,
- }
- } else {
- levelPredicate = {
- $gt: 0,
- }
- }
-
- if (fluidTypePredicate)
- predicate = {
- ...predicate,
- fluidTypes: fluidTypePredicate,
- }
-
- if (levelPredicate) predicate = { ...predicate, level: levelPredicate }
-
- return predicate
- }
-
- public async checkAchievement(id: string): Promise<UserChallenge | null> {
- const challenge = await this.getCurrentChallenge()
- if (
- challenge &&
- challenge.challengeType &&
- challenge.challengeType.type === TypeChallenge.ACHIEVEMENT &&
- challenge.challengeType.id === id
- ) {
- // Achievement is on going, we should update the endingDate
- try {
- const endDate = DateTime.local().startOf('day')
- await this._client
- .query(
- this._client
- .find(USERCHALLENGE_DOCTYPE)
- .where({ _id: challenge.id })
- .limitBy(1)
- )
- .then(async ({ data }) => {
- const doc = data[0]
- await this._client.save({
- ...doc,
- endingDate: endDate,
- })
- })
- challenge.endingDate = endDate
- return challenge
- } catch (error) {
- console.log(error)
- return null
- }
- }
- return null
- }
-
- /*
- * If the challenge is over
- * Set the rigth badge and return true
- * else return false
- */
- public async isCurrentChallengeOver(
- challenge: UserChallenge,
- fluidTypes: FluidType[]
- ): Promise<boolean> {
- try {
- const typeChallenge = challenge.challengeType
- ? challenge.challengeType.type
- : 0
- const isOver = await this.isChallengeOverByDate(
- challenge.endingDate,
- fluidTypes,
- typeChallenge
- )
- if (isOver) {
- await this.setTheRightBadge(challenge)
- return true
- } else {
- return false
- }
- } catch (error) {
- console.log(error)
- throw error
- }
- }
-}
diff --git a/src/services/challengeMapper.service.ts b/src/services/challengeMapper.service.ts
deleted file mode 100644
index 56f93678412d9e74cbc25189bfb065363dac8b37..0000000000000000000000000000000000000000
--- a/src/services/challengeMapper.service.ts
+++ /dev/null
@@ -1,239 +0,0 @@
-import { DateTime, Duration } from 'luxon'
-import { ChallengeState, BadgeState, TypeChallenge } from 'enum/challenge.enum'
-import { UserChallenge, ChallengeType, Ecogesture } from 'models'
-import { FluidType } from 'enum/fluid.enum'
-import { CHALLENGETYPE_DOCTYPE, ECOGESTURE_DOCTYPE } from 'doctypes'
-
-export class UserChallengeEntity {
- _id?: string
- startingDate: string
- endingDate: string
- state: ChallengeState
- maxEnergy: number
- currentEnergy: number
- badge: BadgeState | null
- relationships: object
- fluidTypes: FluidType[]
-
- constructor(
- startingDate: string,
- endingDate: string,
- state: ChallengeState,
- maxEnergy: number,
- currentEnergy: number,
- badge: BadgeState | null,
- relationships: object,
- fluidTypes: FluidType[],
- _id?: string
- ) {
- this.startingDate = startingDate
- this.endingDate = endingDate
- this.state = state
- this.maxEnergy = maxEnergy
- this.currentEnergy = currentEnergy
- this.badge = badge
- this._id = _id
- this.relationships = relationships
- this.fluidTypes = fluidTypes
- }
-}
-
-export class ChallengeTypeEntity {
- _id: string
- type: TypeChallenge
- title: string
- description: string
- level: number
- duration: Duration
- fluidTypes: FluidType[]
- relationships: object
-
- constructor(
- _id: string,
- type: TypeChallenge,
- title: string,
- description: string,
- level: number,
- duration: Duration,
- fluidTypes: FluidType[],
- relationships: object
- ) {
- this._id = _id
- this.type = type
- this.title = title
- this.description = description
- this.level = level
- this.duration = duration
- this.fluidTypes = fluidTypes
- this.relationships = relationships
- }
-}
-
-export default class ChallengeMapperService {
- public mapFromUserChallenge(
- userChallenge: UserChallenge
- ): UserChallengeEntity {
- const mappedEcogestures = userChallenge.selectedEcogestures.map(
- ecogesture => ({
- _id: ecogesture.id,
- _type: ECOGESTURE_DOCTYPE,
- })
- )
-
- const mappedUserChallenge: UserChallengeEntity = {
- startingDate: userChallenge.startingDate.toISO(),
- endingDate: userChallenge.endingDate.toISO(),
- state: userChallenge.state,
- maxEnergy: userChallenge.maxEnergy,
- currentEnergy: userChallenge.currentEnergy,
- badge: userChallenge.badge,
- fluidTypes: userChallenge.fluidTypes,
- relationships: {
- selectedEcogestures: {
- data: mappedEcogestures,
- },
- challengeType: {
- data: {
- _id: userChallenge.challengeType
- ? userChallenge.challengeType.id
- : '',
- _type: CHALLENGETYPE_DOCTYPE,
- },
- },
- },
- }
- return mappedUserChallenge
- }
-
- public mapToUserChallenge(
- userChallengeEntity: UserChallengeEntity,
- userChallengeEntityRelationships?: object | null
- ): UserChallenge {
- let selectedEcogestures: Ecogesture[] = []
- let challengeType: ChallengeType | null = null
-
- if (userChallengeEntityRelationships) {
- const idOfEcogestures = userChallengeEntity.relationships.selectedEcogestures.data.map(
- eg => eg._id
- )
- const challengeTypes = userChallengeEntityRelationships.filter(
- challengeType =>
- challengeType._type === CHALLENGETYPE_DOCTYPE &&
- challengeType._id ===
- userChallengeEntity.relationships.challengeType.data._id
- )
- const EcogesturesRelationships = userChallengeEntityRelationships.filter(
- eg => idOfEcogestures.includes(eg._id)
- )
- selectedEcogestures = EcogesturesRelationships.filter(
- relationship => relationship._type === ECOGESTURE_DOCTYPE
- )
- challengeType = challengeTypes ? challengeTypes[0] : null
- }
-
- const mappedUserChallenge: UserChallenge = {
- id: userChallengeEntity._id,
- startingDate: DateTime.fromISO(userChallengeEntity.startingDate).startOf(
- 'day'
- ),
- endingDate: DateTime.fromISO(userChallengeEntity.endingDate).startOf(
- 'day'
- ),
- state: userChallengeEntity.state,
- selectedEcogestures: selectedEcogestures,
- challengeType: challengeType,
- maxEnergy: userChallengeEntity.maxEnergy,
- currentEnergy: userChallengeEntity.currentEnergy,
- badge: userChallengeEntity.badge,
- fluidTypes: userChallengeEntity.fluidTypes,
- }
-
- return mappedUserChallenge
- }
-
- public mapToChallengeType(
- challengeEntity: ChallengeTypeEntity,
- challengeTypeEntityRelationships?: object | null,
- unlockedEcogestures?: string[]
- // fluidTypes?: FluidType[]
- ): ChallengeType {
- const completeAvailableEcogestures: object[] = []
-
- if (challengeTypeEntityRelationships) {
- for (const ecogestureType of challengeEntity.relationships
- .availableEcogestures.data) {
- const unfilteredEcogestures = challengeTypeEntityRelationships.filter(
- relationship =>
- relationship._type === ECOGESTURE_DOCTYPE &&
- relationship._id === ecogestureType._id
- )
- if (unfilteredEcogestures && unfilteredEcogestures.length === 1)
- completeAvailableEcogestures.push(unfilteredEcogestures[0])
- }
- }
- // --> fluid dependancy for challenge
-
- // let filteredAvailableEcogestures = completeAvailableEcogestures.filter(
- // eg =>
- // fluidTypes &&
- // (fluidTypes.includes(eg.fluidTypes[0]) ||
- // fluidTypes.includes(eg.fluidTypes[1]) ||
- // fluidTypes.includes(eg.fluidTypes[2]))
- // )
-
- let filteredAvailableEcogestures = completeAvailableEcogestures
-
- const fluidFilteredEcogestures = [...new Set(filteredAvailableEcogestures)]
-
- fluidFilteredEcogestures.forEach(eg => {
- if (unlockedEcogestures && !unlockedEcogestures.includes(eg._id)) {
- filteredAvailableEcogestures.push(eg)
- }
- })
-
- filteredAvailableEcogestures = [...new Set(filteredAvailableEcogestures)]
-
- if (filteredAvailableEcogestures.length < 2) {
- filteredAvailableEcogestures = completeAvailableEcogestures
- }
-
- const randomEcogesture =
- filteredAvailableEcogestures[
- Math.floor(Math.random() * filteredAvailableEcogestures.length)
- ]
- const randomEcogestures: Ecogesture[] = filteredAvailableEcogestures.filter(
- eg => eg.pack === randomEcogesture.pack && eg.id !== randomEcogesture.id
- )
-
- randomEcogestures.push(randomEcogesture)
-
- const mappedChallengeType: ChallengeType = {
- id: challengeEntity._id,
- type: challengeEntity.type,
- title: challengeEntity.title,
- description: challengeEntity.description,
- level: challengeEntity.level,
- duration: challengeEntity.duration,
- fluidTypes: challengeEntity.fluidTypes,
- availableEcogestures: randomEcogestures,
- }
-
- return mappedChallengeType
- }
-
- public mapToChallengeTypes(
- challengeEntities: ChallengeTypeEntity[],
- challengeTypeEntityRelationships?: object | null,
- unlockedEcogestures?: string[]
- // fluidTypes?: FluidType[]
- ): ChallengeType[] {
- return challengeEntities.map(challengeEntity =>
- this.mapToChallengeType(
- challengeEntity,
- challengeTypeEntityRelationships,
- unlockedEcogestures
- // fluidTypes
- )
- )
- }
-}
diff --git a/src/services/initialization.service.spec.ts b/src/services/initialization.service.spec.ts
index 4fb015737a44a45de140cfcfd59816be246eeaa0..ad8f26bb6e58b4ba4ee06bff3e8c1e271ec3bf04 100644
--- a/src/services/initialization.service.spec.ts
+++ b/src/services/initialization.service.spec.ts
@@ -1,12 +1,11 @@
import { QueryResult } from 'cozy-client'
import { DateTime } from 'luxon'
-import { FluidStatus, UserChallenge, UserProfile } from 'models'
+import { FluidStatus, Profile } from 'models'
import InitializationService from './initialization.service'
import mockClient from '../../test/__mocks__/client'
import { ecogesturesData } from '../../test/__mocks__/ecogesturesData.mock'
import { challengesTypeData } from '../../test/__mocks__/challengesTypeData.mock'
-import { userChallengeData } from '../../test/__mocks__/userChallengeData.mock'
-import { userProfileData } from '../../test/__mocks__/userProfile.mock'
+import { profileData } from '../../test/__mocks__/profile.mock'
import { fluidStatusData } from '../../test/__mocks__/fluidStatusData.mock'
import challengeTypeData from 'db/challengeTypeData.json'
import ecogestureData from 'db/ecogestureData.json'
@@ -33,13 +32,13 @@ jest.mock('./account.service', () => {
})
})
-const mockGetUserProfile = jest.fn()
-const mockUpdateUserProfile = jest.fn()
-jest.mock('./userProfile.service', () => {
+const mockGetProfile = jest.fn()
+const mockUpdateProfile = jest.fn()
+jest.mock('./profile.service', () => {
return jest.fn(() => {
return {
- getUserProfile: mockGetUserProfile,
- updateUserProfile: mockUpdateUserProfile,
+ getProfile: mockGetProfile,
+ updateProfile: mockUpdateProfile,
}
})
})
@@ -132,65 +131,63 @@ describe('Initialization service', () => {
})
})
- describe('initUserProfile method', () => {
- it('shoud return the userProfil when existing', async () => {
- mockGetUserProfile.mockResolvedValue(userProfileData)
- const result: UserProfile | null = await initializationService.initUserProfile()
- expect(result).toEqual(userProfileData)
+ describe('initProfile method', () => {
+ it('shoud return the profil when existing', async () => {
+ mockGetProfile.mockResolvedValue(profileData)
+ const result: Profile | null = await initializationService.initProfile()
+ expect(result).toEqual(profileData)
})
- it('shoud create and return the userProfil when no existing', async () => {
+ it('shoud create and return the profil when no existing', async () => {
const mockQueryResult: QueryResult<boolean> = {
data: true,
bookmark: '',
next: false,
skip: 0,
}
- mockGetUserProfile
+ mockGetProfile
.mockResolvedValueOnce(null)
- .mockResolvedValueOnce(userProfileData)
+ .mockResolvedValueOnce(profileData)
mockClient.create.mockResolvedValue(mockQueryResult)
- const result: UserProfile | null = await initializationService.initUserProfile()
- expect(result).toEqual(userProfileData)
+ const result: Profile | null = await initializationService.initProfile()
+ expect(result).toEqual(profileData)
})
- it('shoud throw error when the userProfile is not created', async () => {
+ it('shoud throw error when the profile is not created', async () => {
const mockQueryResult: QueryResult<boolean> = {
data: true,
bookmark: '',
next: false,
skip: 0,
}
- mockGetUserProfile.mockResolvedValueOnce(null).mockResolvedValueOnce(null)
+ mockGetProfile.mockResolvedValueOnce(null).mockResolvedValueOnce(null)
mockClient.create.mockResolvedValue(mockQueryResult)
let error
try {
- await initializationService.initUserProfile()
+ await initializationService.initProfile()
} catch (err) {
error = err
}
- expect(error).toEqual(
- new Error('initUserProfile: UserProfile not created')
- )
+ expect(error).toEqual(new Error('initProfile: Profile not created'))
})
- it('shoud throw error when the userProfile could not be fetched', async () => {
- mockGetUserProfile.mockRejectedValueOnce(new Error())
+ it('shoud throw error when the profile could not be fetched', async () => {
+ mockGetProfile.mockRejectedValueOnce(new Error())
let error
try {
- await initializationService.initUserProfile()
+ await initializationService.initProfile()
} catch (err) {
error = err
}
expect(error).toEqual(new Error())
})
- it('shoud throw error when the userProfile failed to be created', async () => {
- mockGetUserProfile.mockResolvedValueOnce(null)
+ it('shoud throw error when the profile failed to be created', async () => {
+ mockGetProfile.mockResolvedValueOnce(null)
mockClient.create.mockRejectedValueOnce(new Error())
let error
try {
- await initializationService.initUserProfile()
+ await initializationService.initProfile()
} catch (err) {
error = err
}
@@ -199,19 +196,18 @@ describe('Initialization service', () => {
})
describe('initChallengeType method', () => {
- //Ok
- it('shoud return true and userProfile when challengeType is already up to date', async () => {
+ it('shoud return true and profile when challengeType is already up to date', async () => {
mockGetAllChallengeTypeEntities.mockResolvedValue(challengeTypeData)
const result: {
result: boolean
- userProfile: UserProfile | null
+ profile: Profile | null
} = await initializationService.initChallengeType(
hashFile(challengeTypeData)
)
- expect(result).toEqual({ result: true, userProfile: null })
+ expect(result).toEqual({ result: true, profile: null })
})
- it('shoud return true and userProfil when challengeType are created', async () => {
+ it('shoud return true and profil when challengeType are created', async () => {
mockGetAllChallengeTypeEntities
.mockResolvedValueOnce(null)
.mockResolvedValueOnce(challengeTypeData)
@@ -222,18 +218,18 @@ describe('Initialization service', () => {
skip: 0,
}
mockClient.create.mockResolvedValue(mockQueryResult)
- const mockUserProfil = {
- ...userProfileData,
+ const mockProfile = {
+ ...profileData,
challengeTypeHash: hashFile(challengeTypeData),
}
- mockUpdateUserProfile.mockResolvedValueOnce(mockUserProfil)
+ mockUpdateProfile.mockResolvedValueOnce(mockProfile)
const result: {
result: boolean
- userProfile: UserProfile | null
+ profile: Profile | null
} = await initializationService.initChallengeType(
hashFile(challengeTypeData)
)
- expect(result).toEqual({ result: true, userProfile: mockUserProfil })
+ expect(result).toEqual({ result: true, profile: mockProfile })
})
it('shoud throw an error when challengeType should be created and created challenge number does not match', async () => {
@@ -262,11 +258,11 @@ describe('Initialization service', () => {
)
})
- it('shoud throw an error when challengeType should be created and updateUserProfile failed', async () => {
+ it('shoud throw an error when challengeType should be created and updateProfile failed', async () => {
mockGetAllChallengeTypeEntities
.mockResolvedValueOnce(null)
.mockResolvedValueOnce(challengeTypeData)
- mockUpdateUserProfile.mockResolvedValueOnce(null)
+ mockUpdateProfile.mockResolvedValueOnce(null)
let error
try {
await initializationService.initChallengeType(
@@ -275,16 +271,14 @@ describe('Initialization service', () => {
} catch (err) {
error = err
}
- expect(error).toEqual(
- new Error('initChallengeType: UserProfile not updated')
- )
+ expect(error).toEqual(new Error('initChallengeType: Profile not updated'))
})
it('shoud throw an error when challengeType should be created and challenge creation failed', async () => {
mockGetAllChallengeTypeEntities
.mockResolvedValueOnce(null)
.mockResolvedValueOnce(challengeTypeData)
- mockUpdateUserProfile.mockRejectedValueOnce(new Error())
+ mockUpdateProfile.mockRejectedValueOnce(new Error())
let error
try {
await initializationService.initChallengeType(
@@ -296,7 +290,7 @@ describe('Initialization service', () => {
expect(error).toEqual(new Error())
})
- it('shoud return true and userProfil when challengeType are updated', async () => {
+ it('shoud return true and profil when challengeType are updated', async () => {
mockGetAllChallengeTypeEntities
.mockResolvedValueOnce(challengeTypeData)
.mockResolvedValueOnce(challengeTypeData)
@@ -308,16 +302,16 @@ describe('Initialization service', () => {
skip: 0,
}
mockClient.create.mockResolvedValue(mockQueryResult)
- const mockUserProfil = {
- ...userProfileData,
+ const mockProfile = {
+ ...profileData,
challengeTypeHash: hashFile(challengeTypeData),
}
- mockUpdateUserProfile.mockResolvedValueOnce(mockUserProfil)
+ mockUpdateProfile.mockResolvedValueOnce(mockProfile)
const result: {
result: boolean
- userProfile: UserProfile | null
+ profile: Profile | null
} = await initializationService.initChallengeType('')
- expect(result).toEqual({ result: true, userProfile: mockUserProfil })
+ expect(result).toEqual({ result: true, profile: mockProfile })
})
it('shoud throw an error when challengeType should be updated and created challenge number does not match', async () => {
@@ -345,21 +339,19 @@ describe('Initialization service', () => {
)
})
- it('shoud throw an error when challengeType should be updated and updateUserProfile failed', async () => {
+ it('shoud throw an error when challengeType should be updated and updateProfile failed', async () => {
mockGetAllChallengeTypeEntities
.mockResolvedValueOnce(challengeTypeData)
.mockResolvedValueOnce(challengeTypeData)
mockDeleteChallengeTypeEntities.mockResolvedValue(true)
- mockUpdateUserProfile.mockResolvedValueOnce(null)
+ mockUpdateProfile.mockResolvedValueOnce(null)
let error
try {
await initializationService.initChallengeType('')
} catch (err) {
error = err
}
- expect(error).toEqual(
- new Error('initChallengeType: UserProfile not updated')
- )
+ expect(error).toEqual(new Error('initChallengeType: Profile not updated'))
})
it('shoud throw an error when challengeType should be updated and challenge creation failed', async () => {
@@ -367,7 +359,7 @@ describe('Initialization service', () => {
.mockResolvedValueOnce(challengeTypeData)
.mockResolvedValueOnce(challengeTypeData)
mockDeleteChallengeTypeEntities.mockResolvedValue(true)
- mockUpdateUserProfile.mockRejectedValueOnce(new Error())
+ mockUpdateProfile.mockRejectedValueOnce(new Error())
let error
try {
await initializationService.initChallengeType('')
@@ -379,13 +371,13 @@ describe('Initialization service', () => {
})
describe('initEcoGesture method', () => {
- it('shoud return true and userProfile = null when ecogestures hash is already up to date', async () => {
+ it('shoud return true and profile = null when ecogestures hash is already up to date', async () => {
mockGetAllEcogestures.mockResolvedValue(ecogestureData)
const result: {
result: boolean
- userProfile: UserProfile | null
+ profile: Profile | null
} = await initializationService.initEcogesture(hashFile(ecogestureData))
- expect(result).toEqual({ result: true, userProfile: null })
+ expect(result).toEqual({ result: true, profile: null })
})
it('shoud return true and ecogestures when ecogestures are created', async () => {
@@ -399,16 +391,16 @@ describe('Initialization service', () => {
skip: 0,
}
mockClient.create.mockResolvedValue(mockQueryResult)
- const mockUserProfil = {
- ...userProfileData,
+ const mockProfile = {
+ ...profileData,
ecogestureHash: hashFile(ecogestureData),
}
- mockUpdateUserProfile.mockResolvedValueOnce(mockUserProfil)
+ mockUpdateProfile.mockResolvedValueOnce(mockProfile)
const result: {
result: boolean
- userProfile: UserProfile | null
+ profile: Profile | null
} = await initializationService.initEcogesture(hashFile(ecogestureData))
- expect(result).toEqual({ result: true, userProfile: mockUserProfil })
+ expect(result).toEqual({ result: true, profile: mockProfile })
})
it('shoud throw an error when ecogestures should be created and created ecogestures number does not match', async () => {
@@ -435,27 +427,25 @@ describe('Initialization service', () => {
)
})
- it('shoud throw an error when ecogestures should be created and updateUserProfile failed', async () => {
+ it('shoud throw an error when ecogestures should be created and updateProfile failed', async () => {
mockGetAllEcogestures
.mockResolvedValueOnce(null)
.mockResolvedValueOnce(ecogestureData)
- mockUpdateUserProfile.mockResolvedValueOnce(null)
+ mockUpdateProfile.mockResolvedValueOnce(null)
let error
try {
await initializationService.initEcogesture(hashFile(ecogestureData))
} catch (err) {
error = err
}
- expect(error).toEqual(
- new Error('initEcogesture: UserProfile not updated')
- )
+ expect(error).toEqual(new Error('initEcogesture: Profile not updated'))
})
it('shoud throw an error when ecogestures should be created and challenge creation failed', async () => {
mockGetAllEcogestures
.mockResolvedValueOnce(null)
.mockResolvedValueOnce(ecogestureData)
- mockUpdateUserProfile.mockRejectedValueOnce(new Error())
+ mockUpdateProfile.mockRejectedValueOnce(new Error())
let error
try {
await initializationService.initEcogesture(hashFile(ecogestureData))
@@ -465,7 +455,7 @@ describe('Initialization service', () => {
expect(error).toEqual(new Error())
})
- it('shoud return true and userProfil when ecogestures are updated', async () => {
+ it('shoud return true and profil when ecogestures are updated', async () => {
mockGetAllEcogestures
.mockResolvedValueOnce(ecogestureData)
.mockResolvedValueOnce(ecogestureData)
@@ -477,16 +467,16 @@ describe('Initialization service', () => {
skip: 0,
}
mockClient.create.mockResolvedValue(mockQueryResult)
- const mockUserProfil = {
- ...userProfileData,
+ const mockProfile = {
+ ...profileData,
ecogestureHash: hashFile(ecogestureData),
}
- mockUpdateUserProfile.mockResolvedValueOnce(mockUserProfil)
+ mockUpdateProfile.mockResolvedValueOnce(mockProfile)
const result: {
result: boolean
- userProfile: UserProfile | null
+ profile: Profile | null
} = await initializationService.initEcogesture('')
- expect(result).toEqual({ result: true, userProfile: mockUserProfil })
+ expect(result).toEqual({ result: true, profile: mockProfile })
})
it('shoud throw an error when ecogestures should be updated and created ecogestures number does not match', async () => {
@@ -514,21 +504,19 @@ describe('Initialization service', () => {
)
})
- it('shoud throw an error when ecogestures should be updated and updateUserProfile failed', async () => {
+ it('shoud throw an error when ecogestures should be updated and updateProfile failed', async () => {
mockGetAllEcogestures
.mockResolvedValueOnce(ecogestureData)
.mockResolvedValueOnce(ecogestureData)
mockDeleteAllEcogestures.mockResolvedValue(true)
- mockUpdateUserProfile.mockResolvedValueOnce(null)
+ mockUpdateProfile.mockResolvedValueOnce(null)
let error
try {
await initializationService.initEcogesture('')
} catch (err) {
error = err
}
- expect(error).toEqual(
- new Error('initEcogesture: UserProfile not updated')
- )
+ expect(error).toEqual(new Error('initEcogesture: Profile not updated'))
})
it('shoud throw an error when ecogestures should be updated and ecogestures creation failed', async () => {
@@ -536,7 +524,7 @@ describe('Initialization service', () => {
.mockResolvedValueOnce(ecogestureData)
.mockResolvedValueOnce(ecogestureData)
mockDeleteAllEcogestures.mockResolvedValue(true)
- mockUpdateUserProfile.mockRejectedValueOnce(new Error())
+ mockUpdateProfile.mockRejectedValueOnce(new Error())
let error
try {
await initializationService.initEcogesture('')
@@ -548,131 +536,65 @@ describe('Initialization service', () => {
})
describe('initReport method', () => {
- it('should return true and userProfile = null when report is up to date', async () => {
- const mockUserReport = {
+ it('should return true and profile when report is up to date', async () => {
+ const mockProfile = {
+ ...profileData,
monthlyReportDate: getActualReportDate(),
- haveSeenLastReport: false,
- sendReportNotification: true,
}
+ console.log(mockProfile)
const result: {
result: boolean
- userProfile: UserProfile | null
- } = await initializationService.initReport(mockUserReport)
- expect(result).toEqual({ result: true, userProfile: null })
- })
-
- it('should return true and userProfile when no report', async () => {
- mockUpdateUserProfile.mockResolvedValueOnce(userProfileData)
- const result: {
- result: boolean
- userProfile: UserProfile | null
- } = await initializationService.initReport(null)
- expect(result).toEqual({
- result: true,
- userProfile: userProfileData,
- })
+ profile: Profile | null
+ } = await initializationService.initReport(mockProfile)
+ expect(result).toEqual({ result: true, profile: mockProfile })
})
- it('should return true and userProfile when report is not up to date', async () => {
- const mockUserReport = {
+ it('should return true and updated profile when report is not up to date', async () => {
+ const mockProfile = {
+ ...profileData,
monthlyReportDate: DateTime.fromISO('2000-10-02T00:00:00.000'),
+ haveSeenLastReport: true,
+ }
+ const updatedProfile = {
+ ...profileData,
+ monthlyReportDate: getActualReportDate(),
haveSeenLastReport: false,
- sendReportNotification: true,
}
- mockUpdateUserProfile.mockResolvedValueOnce(userProfileData)
+ mockUpdateProfile.mockResolvedValueOnce(updatedProfile)
const result: {
result: boolean
- userProfile: UserProfile | null
- } = await initializationService.initReport(mockUserReport)
+ profile: Profile | null
+ } = await initializationService.initReport(mockProfile)
expect(result).toEqual({
result: true,
- userProfile: userProfileData,
+ profile: updatedProfile,
})
})
it('should throw error when report is not up to date and profile is not updated', async () => {
- const mockUserReport = {
+ const mockProfile = {
+ ...profileData,
monthlyReportDate: DateTime.fromISO('2000-10-02T00:00:00.000'),
- haveSeenLastReport: false,
- sendReportNotification: true,
}
- mockUpdateUserProfile.mockResolvedValueOnce(null)
+ mockUpdateProfile.mockResolvedValueOnce(null)
let error
try {
- await initializationService.initReport(mockUserReport)
+ await initializationService.initReport(mockProfile)
} catch (err) {
error = err
}
- expect(error).toEqual(new Error('initReport: UserProfile not updated'))
+ expect(error).toEqual(new Error('initReport: Profile not updated'))
})
it('should throw error when report is not up to date and update profile failed', async () => {
- const mockUserReport = {
+ const mockProfile = {
+ ...profileData,
monthlyReportDate: DateTime.fromISO('2000-10-02T00:00:00.000'),
- haveSeenLastReport: false,
- sendReportNotification: true,
}
- mockUpdateUserProfile.mockRejectedValueOnce(new Error())
+ mockUpdateProfile.mockRejectedValueOnce(new Error())
let error
try {
- await initializationService.initReport(mockUserReport)
- } catch (err) {
- error = err
- }
- expect(error).toEqual(new Error())
- })
- })
-
- describe('initUserChallenge method', () => {
- it('shoud return userchallenges when userchallenges already existing', async () => {
- mockGetAllUserChallenges.mockResolvedValueOnce(userChallengeData)
- const result: UserChallenge[] = await initializationService.initUserChallenge()
- expect(result).toEqual(userChallengeData)
- })
-
- it('shoud return userchallenges when userchallenge should be created', async () => {
- mockGetAllUserChallenges
- .mockResolvedValueOnce([])
- .mockResolvedValueOnce(userChallengeData)
- const mockQueryResult: QueryResult<boolean> = {
- data: true,
- bookmark: '',
- next: false,
- skip: 0,
- }
- mockClient.create.mockResolvedValue(mockQueryResult)
- const result: UserChallenge[] = await initializationService.initUserChallenge()
- expect(result).toEqual(userChallengeData)
- })
-
- it('shoud throw error when userchallenge should be created and userchallenge is not updated', async () => {
- mockGetAllUserChallenges
- .mockResolvedValueOnce([])
- .mockResolvedValueOnce(null)
- const mockQueryResult: QueryResult<boolean> = {
- data: true,
- bookmark: '',
- next: false,
- skip: 0,
- }
- mockClient.create.mockResolvedValue(mockQueryResult)
- let error
- try {
- await initializationService.initUserChallenge()
- } catch (err) {
- error = err
- }
- expect(error).toEqual(
- new Error('initUserChallenge: UserChallenge not updated')
- )
- })
-
- it('shoud throw error when userchallenge failed to be created', async () => {
- mockGetAllUserChallenges.mockResolvedValueOnce([])
- mockClient.create.mockRejectedValueOnce(new Error())
- let error
- try {
- await initializationService.initUserChallenge()
+ await initializationService.initReport(mockProfile)
} catch (err) {
error = err
}
@@ -747,76 +669,4 @@ describe('Initialization service', () => {
expect(error).toEqual(new Error())
})
})
-
- describe('initCurrentChallenge method', () => {
- it('should return updated current Challenge', async () => {
- mockGetCurrentChallenge.mockResolvedValueOnce(userChallengeData)
- const mockUpdatedUserChallenge = {
- ...userChallengeData,
- maxmaxEnergy: 100,
- }
- mockUpdateCurrentChallengeProgress.mockResolvedValueOnce(
- mockUpdatedUserChallenge
- )
- const result: UserChallenge | null = await initializationService.initCurrentChallenge()
- expect(result).toBe(mockUpdatedUserChallenge)
- })
-
- it('should return null if no current Challenge', async () => {
- mockGetCurrentChallenge.mockResolvedValueOnce(null)
- const result: UserChallenge | null = await initializationService.initCurrentChallenge()
- expect(result).toBeNull()
- })
-
- it('should throw error if current challenge failed to be retrieve', async () => {
- mockGetCurrentChallenge.mockRejectedValueOnce(new Error())
- let error
- try {
- await initializationService.initCurrentChallenge()
- } catch (err) {
- error = err
- }
- expect(error).toEqual(new Error())
- })
-
- it('should throw error if current challenge failed to be updated', async () => {
- mockGetCurrentChallenge.mockResolvedValueOnce(userChallengeData)
- mockUpdateCurrentChallengeProgress.mockRejectedValueOnce(new Error())
- let error
- try {
- await initializationService.initCurrentChallenge()
- } catch (err) {
- error = err
- }
- expect(error).toEqual(new Error())
- })
- })
-
- describe('isCurrentChallengeOver method', () => {
- it('should return true if isCurrentChallengeOver return true', async () => {
- mockIsCurrentChallengeOver.mockResolvedValueOnce(true)
- const result: boolean = await initializationService.isCurrentChallengeOver(
- userChallengeData
- )
- expect(result).toBe(true)
- })
-
- it('should return false if isCurrentChallengeOver return false', async () => {
- mockIsCurrentChallengeOver.mockResolvedValueOnce(false)
- const result: boolean = await initializationService.isCurrentChallengeOver(
- userChallengeData
- )
- expect(result).toBe(false)
- })
- })
-
- describe('checkAchievement method', () => {
- it('should return UserChallenge from the id', async () => {
- mockCheckAchievement.mockResolvedValueOnce(userChallengeData)
- const result: UserChallenge | null = await initializationService.checkAchievement(
- '4d9403218ef13e65b2e3a8ad1700c9f0'
- )
- expect(result).toEqual(userChallengeData)
- })
- })
})
diff --git a/src/services/initialization.service.ts b/src/services/initialization.service.ts
index c788df7891bb1cbafd6fc55f605fa03c155c0c95..db2148024e7be276a4c6ae84057353243ef564de 100644
--- a/src/services/initialization.service.ts
+++ b/src/services/initialization.service.ts
@@ -1,9 +1,7 @@
import { Client, Q, QueryDefinition } from 'cozy-client'
import {
- CHALLENGETYPE_DOCTYPE,
ECOGESTURE_DOCTYPE,
- USERCHALLENGE_DOCTYPE,
- USERPROFILE_DOCTYPE,
+ PROFILE_DOCTYPE,
EGL_DAY_DOCTYPE,
EGL_MONTH_DOCTYPE,
EGL_YEAR_DOCTYPE,
@@ -15,23 +13,16 @@ import {
GRDF_HOUR_DOCTYPE,
GRDF_MONTH_DOCTYPE,
GRDF_YEAR_DOCTYPE,
+ ENEDIS_HOUR_DOCTYPE,
} from 'doctypes'
import { FluidType } from 'enum/fluid.enum'
-import {
- FluidStatus,
- ReportAttributes,
- UserChallenge,
- UserProfile,
-} from 'models'
+import { FluidStatus, Profile } from 'models'
-import ChallengeService from 'services/challenge.service'
-import challengeTypeData from 'db/challengeTypeData.json'
-import userChallengeData from 'db/userChallengeData.json'
import EcogestureService from 'services/ecogesture.service'
import ecogestureData from 'db/ecogestureData.json'
-import UserProfileService from 'services/userProfile.service'
-import userProfileData from 'db/userProfileData.json'
+import ProfileService from 'services/profile.service'
+import profileData from 'db/profileData.json'
import KonnectorStatusService from 'services/konnectorStatus.service'
import KonnectorService from 'services/konnector.service'
import AccountService from 'services/account.service'
@@ -39,6 +30,7 @@ import FluidService from 'services/fluid.service'
import { hashFile } from 'utils/hash'
import { getActualReportDate } from 'utils/date'
+import { TimeStep } from 'enum/timeStep.enum'
export default class InitializationService {
private readonly _client: Client
@@ -50,19 +42,78 @@ export default class InitializationService {
/*
* Call a query with where clause to create the index if not exist
*/
- private async createIndex(doctype: string): Promise<object> {
+ private async createIndex(
+ doctype: string,
+ timestep: TimeStep
+ ): Promise<object> {
+ const getMongoSelector = () => {
+ switch (timestep) {
+ case TimeStep.YEAR:
+ return {
+ year: {
+ $lte: 9999,
+ },
+ }
+ case TimeStep.MONTH:
+ return {
+ year: {
+ $lte: 9999,
+ },
+ month: {
+ $lte: 12,
+ },
+ }
+ case TimeStep.DAY:
+ return {
+ year: {
+ $lte: 9999,
+ },
+ month: {
+ $lte: 12,
+ },
+ day: {
+ $lte: 31,
+ },
+ }
+ case TimeStep.HOUR:
+ return {
+ year: {
+ $lte: 9999,
+ },
+ month: {
+ $lte: 12,
+ },
+ day: {
+ $lte: 31,
+ },
+ hour: {
+ $lte: 23,
+ },
+ }
+ case TimeStep.HALF_AN_HOUR:
+ return {
+ year: {
+ $lte: 9999,
+ },
+ month: {
+ $lte: 12,
+ },
+ day: {
+ $lte: 31,
+ },
+ hour: {
+ $lte: 23,
+ },
+ minute: {
+ $let: 30,
+ },
+ }
+ default:
+ return {}
+ }
+ }
const query: QueryDefinition = Q(doctype)
- .where({
- year: {
- $lte: 9999,
- },
- month: {
- $lte: 12,
- },
- day: {
- $lte: 31,
- },
- })
+ .where(getMongoSelector())
.limitBy(1)
return await this._client.query(query)
}
@@ -77,17 +128,18 @@ export default class InitializationService {
const accountService = new AccountService(this._client)
const konnectorService = new KonnectorService(this._client)
await Promise.all([
- this.createIndex(EGL_DAY_DOCTYPE),
- this.createIndex(EGL_MONTH_DOCTYPE),
- this.createIndex(EGL_YEAR_DOCTYPE),
- this.createIndex(ENEDIS_DAY_DOCTYPE),
- this.createIndex(ENEDIS_MINUTE_DOCTYPE),
- this.createIndex(ENEDIS_MONTH_DOCTYPE),
- this.createIndex(ENEDIS_YEAR_DOCTYPE),
- this.createIndex(GRDF_DAY_DOCTYPE),
- this.createIndex(GRDF_HOUR_DOCTYPE),
- this.createIndex(GRDF_MONTH_DOCTYPE),
- this.createIndex(GRDF_YEAR_DOCTYPE),
+ this.createIndex(EGL_YEAR_DOCTYPE, TimeStep.YEAR),
+ this.createIndex(EGL_MONTH_DOCTYPE, TimeStep.MONTH),
+ this.createIndex(EGL_DAY_DOCTYPE, TimeStep.DAY),
+ this.createIndex(ENEDIS_YEAR_DOCTYPE, TimeStep.YEAR),
+ this.createIndex(ENEDIS_MONTH_DOCTYPE, TimeStep.MONTH),
+ this.createIndex(ENEDIS_DAY_DOCTYPE, TimeStep.DAY),
+ this.createIndex(ENEDIS_HOUR_DOCTYPE, TimeStep.HOUR),
+ this.createIndex(ENEDIS_MINUTE_DOCTYPE, TimeStep.HALF_AN_HOUR),
+ this.createIndex(GRDF_YEAR_DOCTYPE, TimeStep.YEAR),
+ this.createIndex(GRDF_MONTH_DOCTYPE, TimeStep.MONTH),
+ this.createIndex(GRDF_DAY_DOCTYPE, TimeStep.DAY),
+ this.createIndex(GRDF_HOUR_DOCTYPE, TimeStep.HOUR),
konnectorService.createIndexKonnector(),
accountService.createIndexAccount(),
])
@@ -103,35 +155,36 @@ export default class InitializationService {
}
/*
- * Check if UserProfil exist
- * If not, the UserProfil is created
- * sucess return: userProfil
+ * Check if profil exist
+ * If not, the profil is created
+ * sucess return: profil
* failure return: null
*/
- public async initUserProfile(): Promise<UserProfile | null> {
- const userProfileService = new UserProfileService(this._client)
+ public async initProfile(): Promise<Profile | null> {
+ const profileService = new ProfileService(this._client)
try {
- const loadedUserProfile = await userProfileService.getUserProfile()
- if (!loadedUserProfile) {
+ const loadedProfile = await profileService.getProfile()
+ if (!loadedProfile) {
// Population with the data
- await this._client.create(USERPROFILE_DOCTYPE, userProfileData[0])
+ await this._client.create(PROFILE_DOCTYPE, profileData[0])
// Check of created document
- const checkUserProfile = await userProfileService.getUserProfile()
- if (checkUserProfile) {
+ const checkProfile = await profileService.getProfile()
+ if (checkProfile) {
console.log(
- '%c Initialization: User Profile created',
+ '%c Initialization: Profile created',
'background: #222; color: white'
)
- return checkUserProfile
+ return checkProfile
} else {
- throw new Error('initUserProfile: UserProfile not created')
+ throw new Error('initProfile: Profile not created')
}
} else {
console.log(
- '%c Initialization: User Profile loaded',
+ '%c Initialization: Profile loaded',
'background: #222; color: white'
)
- return loadedUserProfile
+ // TODO ensure that actual profile has all needed attributes
+ return loadedProfile
}
} catch (error) {
console.log('Initialization error: ', error)
@@ -139,108 +192,12 @@ export default class InitializationService {
}
}
- public async initChallengeType(
- hash: string
- ): Promise<{ result: boolean; userProfile: UserProfile | null }> {
- const hashChanllengeType = hashFile(challengeTypeData)
- const challengeService = new ChallengeService(this._client)
- const userProfileService = new UserProfileService(this._client)
-
- // Populate data if none challengeType exists
- const loadedChallengeTypes = await challengeService.getAllChallengeTypeEntities()
- if (
- !loadedChallengeTypes ||
- (loadedChallengeTypes && loadedChallengeTypes.length === 0)
- ) {
- // Populate the doctype with data
- try {
- for (let i = 0; i <= challengeTypeData.length - 1; i++) {
- await this._client.create(CHALLENGETYPE_DOCTYPE, challengeTypeData[i])
- }
- // Check of created document
- const checkCount = await challengeService.getAllChallengeTypeEntities()
- if (
- !checkCount ||
- (checkCount && checkCount.length !== challengeTypeData.length)
- ) {
- throw new Error(
- 'initChallengeType: Created challenge type entities does not macht'
- )
- }
- // Update userProfil with the hash
- const updatedUserProfile = await userProfileService.updateUserProfile({
- challengeTypeHash: hashChanllengeType,
- })
- if (updatedUserProfile) {
- console.log(
- '%c Initialization: Challenge Type created',
- 'background: #222; color: white'
- )
- return { result: true, userProfile: updatedUserProfile }
- } else {
- throw new Error('initChallengeType: UserProfile not updated')
- }
- } catch (error) {
- console.log('Initialization error: ', error)
- throw error
- }
- }
-
- // Update if the hash is not the same as the one from userprofile
- if (hash !== hashChanllengeType) {
- // Update the doctype
- try {
- // Deletion of all documents
- await challengeService.deleteAllChallengeTypeEntities()
- // Population with the data
- await Promise.all(
- challengeTypeData.map(async challengeType => {
- await this._client.create(CHALLENGETYPE_DOCTYPE, challengeType)
- })
- )
- // Check of created document
- const checkCount = await challengeService.getAllChallengeTypeEntities()
- if (
- !checkCount ||
- (checkCount && checkCount.length !== challengeTypeData.length)
- ) {
- throw new Error(
- 'initChallengeType: Created challenge type entities does not macht'
- )
- }
- // Update userProfil with the hash
- const updatedUserProfile = await userProfileService.updateUserProfile({
- challengeTypeHash: hashChanllengeType,
- })
- if (updatedUserProfile) {
- console.log(
- '%c Initialization: Challenge Type updated',
- 'background: #222; color: white'
- )
- return { result: true, userProfile: updatedUserProfile }
- } else {
- throw new Error('initChallengeType: UserProfile not updated')
- }
- } catch (error) {
- console.log('Initialization error: ', error)
- throw error
- }
- } else {
- // Doctype already up to date
- console.log(
- '%c Initialization: Challenge Type loaded',
- 'background: #222; color: white'
- )
- return { result: true, userProfile: null }
- }
- }
-
public async initEcogesture(
hash: string
- ): Promise<{ result: boolean; userProfile: UserProfile | null }> {
+ ): Promise<{ result: boolean; profile: Profile | null }> {
const hashEcogestureType = hashFile(ecogestureData)
const ecogestureService = new EcogestureService(this._client)
- const userProfileService = new UserProfileService(this._client)
+ const profileService = new ProfileService(this._client)
// Populate data if none ecogesture exists
const loadedEcogestures = await ecogestureService.getAllEcogestures()
@@ -263,18 +220,18 @@ export default class InitializationService {
'initEcogesture: Created ecogesture type entities does not macht'
)
}
- // Update userProfil with the hash
- const updatedUserProfile = await userProfileService.updateUserProfile({
+ // Update profil with the hash
+ const updatedProfile = await profileService.updateProfile({
ecogestureHash: hashEcogestureType,
})
- if (updatedUserProfile) {
+ if (updatedProfile) {
console.log(
'%c Initialization: Ecogesture created',
'background: #222; color: white'
)
- return { result: true, userProfile: updatedUserProfile }
+ return { result: true, profile: updatedProfile }
} else {
- throw new Error('initEcogesture: UserProfile not updated')
+ throw new Error('initEcogesture: Profile not updated')
}
} catch (error) {
console.log('Initialization error: ', error)
@@ -282,7 +239,7 @@ export default class InitializationService {
}
}
- // Update if the hash is not the same as the one from userprofile
+ // Update if the hash is not the same as the one from profile
if (hash !== hashEcogestureType) {
// Update the doctype
try {
@@ -304,18 +261,18 @@ export default class InitializationService {
'initEcogesture: Created ecogesture type entities does not macht'
)
}
- // Update userProfil with the hash
- const updatedUserProfile = await userProfileService.updateUserProfile({
+ // Update profil with the hash
+ const updatedProfile = await profileService.updateProfile({
ecogestureHash: hashEcogestureType,
})
- if (updatedUserProfile) {
+ if (updatedProfile) {
console.log(
'%c Initialization: Ecogesture updated',
'background: #222; color: white'
)
- return { result: true, userProfile: updatedUserProfile }
+ return { result: true, profile: updatedProfile }
} else {
- throw new Error('initEcogesture: UserProfile not updated')
+ throw new Error('initEcogesture: Profile not updated')
}
} catch (error) {
console.log('Initialization error: ', error)
@@ -327,96 +284,151 @@ export default class InitializationService {
'%c Initialization: Ecogesture loaded',
'background: #222; color: white'
)
- return { result: true, userProfile: null }
+ return { result: true, profile: null }
}
}
+ // TODO Transform to initSeasons
+ // public async initChallengeType(
+ // hash: string
+ // ): Promise<{
+ // result: boolean
+ // profile: Profile | null
+ // }> {
+ // const hashChanllengeType = hashFile(challengeTypeData)
+ // const challengeService = new ChallengeService(this._client)
+ // const profileService = new ProfileService(this._client)
+
+ // // Populate data if none challengeType exists
+ // const loadedChallengeTypes = await challengeService.getAllChallengeTypeEntities()
+ // if (
+ // !loadedChallengeTypes ||
+ // (loadedChallengeTypes && loadedChallengeTypes.length === 0)
+ // ) {
+ // // Populate the doctype with data
+ // try {
+ // for (let i = 0; i <= challengeTypeData.length - 1; i++) {
+ // await this._client.create(CHALLENGETYPE_DOCTYPE, challengeTypeData[i])
+ // }
+ // // Check of created document
+ // const checkCount = await challengeService.getAllChallengeTypeEntities()
+ // if (
+ // !checkCount ||
+ // (checkCount && checkCount.length !== challengeTypeData.length)
+ // ) {
+ // throw new Error(
+ // 'initChallengeType: Created challenge type entities does not macht'
+ // )
+ // }
+ // // Update profil with the hash
+ // const updatedProfile = await profileService.updateProfile({
+ // challengeTypeHash: hashChanllengeType,
+ // })
+ // if (updatedProfile) {
+ // console.log(
+ // '%c Initialization: Challenge Type created',
+ // 'background: #222; color: white'
+ // )
+ // return {
+ // result: true,
+ // profile: updatedProfile,
+ // }
+ // } else {
+ // throw new Error('initChallengeType: Profile not updated')
+ // }
+ // } catch (error) {
+ // console.log('Initialization error: ', error)
+ // throw error
+ // }
+ // }
+
+ // // Update if the hash is not the same as the one from profile
+ // if (hash !== hashChanllengeType) {
+ // // Update the doctype
+ // try {
+ // // Deletion of all documents
+ // await challengeService.deleteAllChallengeTypeEntities()
+ // // Population with the data
+ // await Promise.all(
+ // challengeTypeData.map(async challengeType => {
+ // await this._client.create(CHALLENGETYPE_DOCTYPE, challengeType)
+ // })
+ // )
+ // // Check of created document
+ // const checkCount = await challengeService.getAllChallengeTypeEntities()
+ // if (
+ // !checkCount ||
+ // (checkCount && checkCount.length !== challengeTypeData.length)
+ // ) {
+ // throw new Error(
+ // 'initChallengeType: Created challenge type entities does not macht'
+ // )
+ // }
+ // // Update profil with the hash
+ // const updatedProfile = await profileService.updateProfile({
+ // challengeTypeHash: hashChanllengeType,
+ // })
+ // if (updatedProfile) {
+ // console.log(
+ // '%c Initialization: Challenge Type updated',
+ // 'background: #222; color: white'
+ // )
+ // return {
+ // result: true,
+ // profile: updatedProfile,
+ // }
+ // } else {
+ // throw new Error('initChallengeType: Profile not updated')
+ // }
+ // } catch (error) {
+ // console.log('Initialization error: ', error)
+ // throw error
+ // }
+ // } else {
+ // // Doctype already up to date
+ // console.log(
+ // '%c Initialization: Challenge Type loaded',
+ // 'background: #222; color: white'
+ // )
+ // return { result: true, profile: null }
+ // }
+ // }
+
public async initReport(
- userReport: ReportAttributes | null
+ profile: Profile
): Promise<{
result: boolean
- userProfile: UserProfile | null
+ profile: Profile | null
}> {
try {
const actualReportDate = getActualReportDate()
- let isReport = false
- if (!userReport) {
- //INIT REPORT OBJECT
- isReport = true
- userReport = {
- monthlyReportDate: actualReportDate,
- haveSeenLastReport: false,
- sendReportNotification: true,
- }
- }
-
- if (isReport || actualReportDate > userReport.monthlyReportDate) {
- const reportAttributes = {
+ if (
+ profile.monthlyReportDate &&
+ actualReportDate <= profile.monthlyReportDate
+ ) {
+ return { result: true, profile: profile }
+ } else {
+ const profileService = new ProfileService(this._client)
+ const updatedProfile = await profileService.updateProfile({
monthlyReportDate: actualReportDate,
haveSeenLastReport: false,
- sendReportNotification: userReport.sendReportNotification,
- }
- const userProfileService = new UserProfileService(this._client)
- const updatedUserProfile = await userProfileService.updateUserProfile({
- report: reportAttributes,
})
- if (updatedUserProfile) {
+ if (updatedProfile) {
console.log(
- '%c Initialization: Report from userProfile updated',
+ '%c Initialization: Report information from profile updated',
'background: #222; color: white'
)
- return { result: true, userProfile: updatedUserProfile }
+ return { result: true, profile: updatedProfile }
} else {
- throw new Error('initReport: UserProfile not updated')
+ throw new Error('initReport: Profile not updated')
}
}
- return { result: true, userProfile: null }
} catch (error) {
console.log('Initialization error: ', error)
throw error
}
}
- /*
- * Check if userChallenge exist
- * If not, the userChallenge is created
- * sucess return: UserChallenge[]
- * failure throw Error
- */
- public async initUserChallenge(): Promise<UserChallenge[]> {
- const challengeService = new ChallengeService(this._client)
- const loadedUserChallenge = await challengeService.getAllUserChallenges()
- if (
- !loadedUserChallenge ||
- (loadedUserChallenge && loadedUserChallenge.length === 0)
- ) {
- try {
- // Population with the data
- await this._client.create(USERCHALLENGE_DOCTYPE, userChallengeData[0])
- // Check of created document
- const checkUserChallenge = await challengeService.getAllUserChallenges()
- if (checkUserChallenge) {
- console.log(
- '%c Initialization: User Challenge created',
- 'background: #222; color: white'
- )
- return checkUserChallenge
- } else {
- throw new Error('initUserChallenge: UserChallenge not updated')
- }
- } catch (error) {
- console.log('Initialization error: ', error)
- throw error
- }
- } else {
- console.log(
- '%c Initialization: User Challenge loaded',
- 'background: #222; color: white'
- )
- return loadedUserChallenge
- }
- }
-
/*
* Check if FluidTypes exist
* sucess return: FluidType[]
@@ -464,49 +476,4 @@ export default class InitializationService {
throw error
}
}
-
- /*
- * Search for a current challenge
- * and update it if found
- */
- public async initCurrentChallenge(): Promise<UserChallenge | null> {
- try {
- // get the current challenge
- const challengeService = new ChallengeService(this._client)
- const currentChallenge = await challengeService.getCurrentChallenge()
- if (!currentChallenge) {
- // No current challenge
- return null
- } else {
- const updatedChallenge = await challengeService.updateCurrentChallengeProgress(
- currentChallenge
- )
- return updatedChallenge
- }
- } catch (error) {
- console.log('Initialization error: ', error)
- throw error
- }
- }
-
- /*
- * If the challenge is over
- * Set the rigth badge and return true
- * else return false
- */
- public async isCurrentChallengeOver(
- challenge: UserChallenge
- ): Promise<boolean> {
- const challengeService = new ChallengeService(this._client)
- const isOver = await challengeService.isCurrentChallengeOver(
- challenge,
- challenge.fluidTypes
- )
- return isOver
- }
-
- public async checkAchievement(id: string): Promise<UserChallenge | null> {
- const challengeService = new ChallengeService(this._client)
- return await challengeService.checkAchievement(id)
- }
}
diff --git a/src/services/userProfile.service.spec.ts b/src/services/profile.service.spec.ts
similarity index 62%
rename from src/services/userProfile.service.spec.ts
rename to src/services/profile.service.spec.ts
index 1e944097d181c69fb50d7d3310055f56900346f3..98c23baeed45d2ce7152128a479adb7b62cd33fd 100644
--- a/src/services/userProfile.service.spec.ts
+++ b/src/services/profile.service.spec.ts
@@ -1,41 +1,31 @@
-import UserProfileService from './userProfile.service'
-import { Client, QueryResult } from 'cozy-client'
-import { UserProfile } from 'models'
-import { userProfileData } from '../../test/__mocks__/userProfile.mock'
+import ProfileService from './profile.service'
+import { QueryResult } from 'cozy-client'
import { DateTime } from 'luxon'
-
-const mockClient = ({
- find: jest.fn(),
- query: jest.fn(),
- create: jest.fn(),
- destroy: jest.fn(),
- save: jest.fn(),
-} as unknown) as jest.Mocked<Client>
+import { Profile } from 'models'
+import { profileData } from '../../test/__mocks__/profile.mock'
+import mockClient from '../../test/__mocks__/client'
describe('UserProfile service', () => {
- const userProfileService = new UserProfileService(mockClient)
+ const profileService = new ProfileService(mockClient)
describe('getUserProfile', () => {
it('shoud return the user profile', async () => {
- const mockQueryResult: QueryResult<UserProfile[]> = {
- data: [userProfileData],
+ const mockQueryResult: QueryResult<Profile[]> = {
+ data: [profileData],
bookmark: '',
next: false,
skip: 0,
}
mockClient.query.mockResolvedValueOnce(mockQueryResult)
- const result = await userProfileService.getUserProfile()
- expect(result).toEqual(userProfileData)
+ const result = await profileService.getProfile()
+ expect(result).toEqual(profileData)
})
- it('shoud return the user profile from string haveSeenOldFluidModal', async () => {
+ it('shoud return the user profile from string haveSeenOldFluidModal & monthlyReportDate', async () => {
const userProfile = {
- ...userProfileData,
+ ...profileData,
haveSeenOldFluidModal: '2020-11-09T11:27:30.073+01:00',
- report: {
- ...userProfileData.report,
- monthlyReportDate: '2020-11-03T00:00:00.000+01:00',
- },
+ monthlyReportDate: '2020-11-09T11:27:30.073+01:00',
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const mockQueryResult: QueryResult<any[]> = {
@@ -46,28 +36,25 @@ describe('UserProfile service', () => {
}
mockClient.query.mockResolvedValueOnce(mockQueryResult)
const resultUserProfile = {
- ...userProfileData,
+ ...profileData,
haveSeenOldFluidModal: DateTime.fromISO(
'2020-11-09T11:27:30.073+01:00'
),
- report: {
- ...userProfileData.report,
- monthlyReportDate: DateTime.fromISO('2020-11-03T00:00:00.000+01:00'),
- },
+ monthlyReportDate: DateTime.fromISO('2020-11-09T11:27:30.073+01:00'),
}
- const result = await userProfileService.getUserProfile()
+ const result = await profileService.getProfile()
expect(result).toEqual(resultUserProfile)
})
it('shoud return null if no user profile found', async () => {
- const mockQueryResult: QueryResult<UserProfile[]> = {
+ const mockQueryResult: QueryResult<Profile[]> = {
data: [],
bookmark: '',
next: false,
skip: 0,
}
mockClient.query.mockResolvedValueOnce(mockQueryResult)
- const result = await userProfileService.getUserProfile()
+ const result = await profileService.getProfile()
expect(result).toBeNull()
})
})
@@ -75,12 +62,9 @@ describe('UserProfile service', () => {
describe('updateUserProfile', () => {
it('shoud return an updated user profile', async () => {
const userProfile = {
- ...userProfileData,
+ ...profileData,
haveSeenOldFluidModal: '2020-11-09T11:27:30.073+01:00',
- report: {
- ...userProfileData.report,
- monthlyReportDate: '2020-11-03T00:00:00.000+01:00',
- },
+ monthlyReportDate: '2020-11-03T00:00:00.000+01:00',
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const mockQueryResult: QueryResult<any[]> = {
@@ -103,17 +87,14 @@ describe('UserProfile service', () => {
}
mockClient.save.mockResolvedValueOnce(mockUpdatedQueryResult)
const resultUserProfile = {
- ...userProfileData,
+ ...profileData,
haveSeenOldFluidModal: DateTime.fromISO(
'2020-11-09T11:27:30.073+01:00'
),
- report: {
- ...userProfileData.report,
- monthlyReportDate: DateTime.fromISO('2020-11-03T00:00:00.000+01:00'),
- },
+ monthlyReportDate: DateTime.fromISO('2020-11-03T00:00:00.000+01:00'),
haveSeenFavoriteModal: false,
}
- const result = await userProfileService.updateUserProfile({
+ const result = await profileService.updateProfile({
haveSeenFavoriteModal: false,
})
@@ -121,8 +102,8 @@ describe('UserProfile service', () => {
})
it('shoud return null if no user profile found', async () => {
- const mockQueryResult: QueryResult<UserProfile[]> = {
- data: [userProfileData],
+ const mockQueryResult: QueryResult<Profile[]> = {
+ data: [profileData],
bookmark: '',
next: false,
skip: 0,
@@ -135,7 +116,7 @@ describe('UserProfile service', () => {
skip: 0,
}
mockClient.save.mockResolvedValueOnce(mockUpdatedQueryResult)
- const result = await userProfileService.updateUserProfile({
+ const result = await profileService.updateProfile({
haveSeenFavoriteModal: false,
})
expect(result).toBeNull()
diff --git a/src/services/profile.service.ts b/src/services/profile.service.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8d1b3dd22a0b7205b47b62bd9a8e3012d4c07332
--- /dev/null
+++ b/src/services/profile.service.ts
@@ -0,0 +1,53 @@
+import { Client, Q, QueryDefinition } from 'cozy-client'
+import { Profile } from 'models'
+import { PROFILE_DOCTYPE } from 'doctypes'
+import { DateTime } from 'luxon'
+
+export default class ProfileService {
+ private readonly _client: Client
+
+ constructor(_client: Client) {
+ this._client = _client
+ }
+
+ public async getProfile(): Promise<Profile | null> {
+ const query: QueryDefinition = Q(PROFILE_DOCTYPE)
+ const { data } = await this._client.query(query.limitBy(1))
+ const profile: Profile | null = data[0] ? data[0] : null
+ if (profile && typeof profile.haveSeenOldFluidModal === 'string') {
+ profile.haveSeenOldFluidModal = DateTime.fromISO(
+ profile.haveSeenOldFluidModal
+ )
+ }
+ if (profile && typeof profile.monthlyReportDate === 'string') {
+ profile.monthlyReportDate = DateTime.fromISO(profile.monthlyReportDate)
+ }
+ return profile
+ }
+
+ public async updateProfile(attributes: {
+ [key: string]: string | string[] | boolean | number | DateTime
+ }): Promise<Profile | null> {
+ const query: QueryDefinition = Q(PROFILE_DOCTYPE)
+ const { data: profile } = await this._client
+ .query(query.limitBy(1))
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ .then(async ({ data }: any) => {
+ const doc = data[0]
+ const saveResult = await this._client.save({
+ ...doc,
+ ...attributes,
+ })
+ return saveResult
+ })
+ if (profile && typeof profile.haveSeenOldFluidModal === 'string') {
+ profile.haveSeenOldFluidModal = DateTime.fromISO(
+ profile.haveSeenOldFluidModal
+ )
+ }
+ if (profile && typeof profile.monthlyReportDate === 'string') {
+ profile.monthlyReportDate = DateTime.fromISO(profile.monthlyReportDate)
+ }
+ return profile ? profile : null
+ }
+}
diff --git a/src/services/userProfile.service.ts b/src/services/userProfile.service.ts
deleted file mode 100644
index 33f6d712d048331fab1319f4332326f8799fcccf..0000000000000000000000000000000000000000
--- a/src/services/userProfile.service.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-import { Client, Q, QueryDefinition } from 'cozy-client'
-import { UserProfile } from 'models'
-import { USERPROFILE_DOCTYPE } from 'doctypes'
-import { DateTime } from 'luxon'
-import { ReportAttributes } from 'models'
-
-export default class UserProfileService {
- private readonly _client: Client
-
- constructor(_client: Client) {
- this._client = _client
- }
-
- public async getUserProfile(): Promise<UserProfile | null> {
- const query: QueryDefinition = Q(USERPROFILE_DOCTYPE)
- const { data } = await this._client.query(query.limitBy(1))
- const userProfile: UserProfile | null = data[0] ? data[0] : null
- if (userProfile && typeof userProfile.haveSeenOldFluidModal === 'string') {
- userProfile.haveSeenOldFluidModal = DateTime.fromISO(
- userProfile.haveSeenOldFluidModal
- )
- }
- //INIT REPORT OBJECT
- if (
- userProfile &&
- userProfile.report &&
- typeof userProfile.report.monthlyReportDate === 'string'
- ) {
- userProfile.report.monthlyReportDate = DateTime.fromISO(
- userProfile.report.monthlyReportDate
- )
- }
- return userProfile
- }
-
- public async updateUserProfile(attributes: {
- [key: string]:
- | string
- | string[]
- | boolean
- | number
- | DateTime
- | ReportAttributes
- }): Promise<UserProfile | null> {
- const query: QueryDefinition = Q(USERPROFILE_DOCTYPE)
- const { data: userProfile } = await this._client
- .query(query.limitBy(1))
- .then(async ({ data }: any) => {
- const doc = data[0]
- const saveResult = await this._client.save({
- ...doc,
- ...attributes,
- })
- return saveResult
- })
- if (userProfile && typeof userProfile.haveSeenOldFluidModal === 'string') {
- userProfile.haveSeenOldFluidModal = DateTime.fromISO(
- userProfile.haveSeenOldFluidModal
- )
- }
- if (
- userProfile &&
- typeof userProfile.report.monthlyReportDate === 'string'
- ) {
- userProfile.report.monthlyReportDate = DateTime.fromISO(
- userProfile.report.monthlyReportDate
- )
- }
- return userProfile ? userProfile : null
- }
-}
diff --git a/src/store/global/global.actions.ts b/src/store/global/global.actions.ts
new file mode 100644
index 0000000000000000000000000000000000000000..13a9e227449cb5dc7f9e195862ec5771c315b2b0
--- /dev/null
+++ b/src/store/global/global.actions.ts
@@ -0,0 +1,46 @@
+import { ScreenType } from 'enum/screen.enum'
+
+export const CHANGE_SCREEN_TYPE = 'CHANGE_SCREEN_TYPE'
+export const TOOGLE_SEASON_NOTIFICATION = 'TOOGLE_SEASON_NOTIFICATION'
+export const TOOGLE_REPORT_NOTIFICATION = 'TOOGLE_REPORT_NOTIFICATION'
+
+interface ChangeScreenType {
+ type: typeof CHANGE_SCREEN_TYPE
+ payload?: ScreenType
+}
+
+interface ToogleSeasonNotification {
+ type: typeof TOOGLE_SEASON_NOTIFICATION
+ payload?: boolean
+}
+
+interface ToogleReportNotification {
+ type: typeof TOOGLE_REPORT_NOTIFICATION
+ payload?: boolean
+}
+
+export type GlobalActionTypes =
+ | ChangeScreenType
+ | ToogleSeasonNotification
+ | ToogleReportNotification
+
+export function changeScreenType(screenType: ScreenType): GlobalActionTypes {
+ return {
+ type: CHANGE_SCREEN_TYPE,
+ payload: screenType,
+ }
+}
+
+export function toogleSeasonNotification(notif: boolean): GlobalActionTypes {
+ return {
+ type: TOOGLE_SEASON_NOTIFICATION,
+ payload: notif,
+ }
+}
+
+export function toogleReportNotification(notif: boolean): GlobalActionTypes {
+ return {
+ type: TOOGLE_REPORT_NOTIFICATION,
+ payload: notif,
+ }
+}
diff --git a/src/store/global/global.reducer.ts b/src/store/global/global.reducer.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1feaaf5faab581444a30652c4d54642a27b91059
--- /dev/null
+++ b/src/store/global/global.reducer.ts
@@ -0,0 +1,46 @@
+import { Reducer } from 'redux'
+import {
+ CHANGE_SCREEN_TYPE,
+ TOOGLE_SEASON_NOTIFICATION,
+ TOOGLE_REPORT_NOTIFICATION,
+ GlobalActionTypes,
+} from 'store/global/global.actions'
+import { GlobalState } from 'models'
+import { ScreenType } from 'enum/screen.enum'
+
+const initialState: GlobalState = {
+ screenType: ScreenType.MOBILE,
+ seasonNotification: false,
+ reportNotification: false,
+}
+
+export const globalReducer: Reducer<GlobalState> = (
+ state = initialState,
+ action: GlobalActionTypes
+): GlobalState => {
+ switch (action.type) {
+ case CHANGE_SCREEN_TYPE:
+ const screenType =
+ action.payload != undefined ? action.payload : state.screenType
+ return {
+ ...state,
+ screenType: screenType,
+ }
+ case TOOGLE_SEASON_NOTIFICATION:
+ const notifSeason =
+ action.payload != undefined ? action.payload : state.seasonNotification
+ return {
+ ...state,
+ seasonNotification: notifSeason,
+ }
+ case TOOGLE_REPORT_NOTIFICATION:
+ const notifReport =
+ action.payload != undefined ? action.payload : state.reportNotification
+ return {
+ ...state,
+ reportNotification: notifReport,
+ }
+ default:
+ return state
+ }
+}
diff --git a/src/store/index.ts b/src/store/index.ts
index 625802664aeada972ea401dbce56b75eb5c581a2..2387666f9fa5386da02d42d965eb4636a9668d57 100644
--- a/src/store/index.ts
+++ b/src/store/index.ts
@@ -1,8 +1,16 @@
-import { ModalState } from 'models'
+import { GlobalState, ModalState, Profile } from 'models'
+import { globalReducer } from 'store/global/global.reducer'
+import { profileReducer } from './profile/profile.reducer'
import { modalReducer } from 'store/modal/modal.reducer'
export interface EcolyoState {
+ global: GlobalState
+ profile: Profile
modal: ModalState
}
-export const ecolyoReducer = { modal: modalReducer }
+export const ecolyoReducer = {
+ global: globalReducer,
+ profile: profileReducer,
+ modal: modalReducer,
+}
diff --git a/src/store/profile/profile.actions.ts b/src/store/profile/profile.actions.ts
new file mode 100644
index 0000000000000000000000000000000000000000..35e431e42deff302b9130052156db564c4a58728
--- /dev/null
+++ b/src/store/profile/profile.actions.ts
@@ -0,0 +1,28 @@
+import { Profile } from 'models'
+
+export const UPDATE_PROFILE = 'UPDATE_PROFILE'
+export const SET_FIRST_CONNECTION = 'SET_FIRST_CONNECTION'
+
+interface UpdateProfile {
+ type: typeof UPDATE_PROFILE
+ payload?: Profile
+}
+
+interface SetFirstConnection {
+ type: typeof SET_FIRST_CONNECTION
+}
+
+export type ProfileActionTypes = UpdateProfile | SetFirstConnection
+
+export function updateProfile(profile: Profile): ProfileActionTypes {
+ return {
+ type: UPDATE_PROFILE,
+ payload: profile,
+ }
+}
+
+export function setFirstConnection(): ProfileActionTypes {
+ return {
+ type: SET_FIRST_CONNECTION,
+ }
+}
diff --git a/src/store/profile/profile.reducer.ts b/src/store/profile/profile.reducer.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e0625cfd7444ca411f7554d640b2e68cb884027b
--- /dev/null
+++ b/src/store/profile/profile.reducer.ts
@@ -0,0 +1,40 @@
+import { Reducer } from 'redux'
+import {
+ UPDATE_PROFILE,
+ SET_FIRST_CONNECTION,
+ ProfileActionTypes,
+} from 'store/profile/profile.actions'
+import { Profile } from 'models'
+import { DateTime } from 'luxon'
+
+const initialState: Profile = {
+ id: '',
+ challengeTypeHash: '',
+ ecogestureHash: '',
+ isFirstConnection: true,
+ haveSeenFavoriteModal: false,
+ haveSeenOldFluidModal: true,
+ haveSeenLastReport: true,
+ sendReportNotification: false,
+ monthlyReportDate: DateTime.fromISO('0000-01-01T00:00:00.000Z'),
+}
+
+export const profileReducer: Reducer<Profile> = (
+ state = initialState,
+ action: ProfileActionTypes
+): Profile => {
+ switch (action.type) {
+ case UPDATE_PROFILE:
+ return {
+ ...state,
+ ...action.payload,
+ }
+ case SET_FIRST_CONNECTION:
+ return {
+ ...state,
+ isFirstConnection: false,
+ }
+ default:
+ return state
+ }
+}
diff --git a/src/utils/date.ts b/src/utils/date.ts
index 12306c0d00e99e79329f2ee517f4dcfc8350143f..093c373173bdd5b36d79afc2a578c59ea7798de2 100644
--- a/src/utils/date.ts
+++ b/src/utils/date.ts
@@ -155,7 +155,7 @@ export const convertDateToMonthString = (date: DateTime): string => {
}
}
-export function getActualReportDate(): DateTime {
+export const getActualReportDate = (): DateTime => {
const now = DateTime.local().startOf('day')
if (now.day < 3) {
return now.set({ day: 3, month: now.month - 1 })
diff --git a/src/utils/hash.ts b/src/utils/hash.ts
index 8bd0a97296121f4e0e8c3b9aed0d3fd7f555e0f3..b444432ed33b5e7f25d30a852046a207d50504dd 100644
--- a/src/utils/hash.ts
+++ b/src/utils/hash.ts
@@ -3,6 +3,7 @@ import hash from 'object-hash'
/***
* sha1 hex encoding (default)
*/
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
export function hashFile(file: any) {
return hash(file)
}
diff --git a/test/__mocks__/profile.mock.ts b/test/__mocks__/profile.mock.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5f88910d0360059b3da11c91dd4b05dec7b5cd15
--- /dev/null
+++ b/test/__mocks__/profile.mock.ts
@@ -0,0 +1,15 @@
+import { DateTime } from 'luxon'
+
+export const profileData = {
+ _id: '4d9403218ef13e65b2e3a8ad1700bc41',
+ _rev: '16-57473da4fc26315247c217083175dfa0',
+ id: '4d9403218ef13e65b2e3a8ad1700bc41',
+ challengeTypeHash: '1136feb6185c7643e071d14180c0e95782aa4ba3',
+ ecogestureHash: '9798a0aaccb47cff906fc4931a2eff5f9371dd8b',
+ isFirstConnection: true,
+ haveSeenFavoriteModal: false,
+ haveSeenOldFluidModal: false,
+ haveSeenLastReport: true,
+ monthlyReportDate: DateTime.fromISO('2020-11-03T00:00:00.000+01:00'),
+ sendReportNotification: false,
+}