From 04f549af4d6554949dede41e526fa047e340e16c Mon Sep 17 00:00:00 2001 From: frozenhelium Date: Tue, 25 Aug 2026 03:12:44 +0545 Subject: [PATCH 1/2] feat(ui): add baseline content alignment for inline layout - Accept baseline as a contentAlignment option on InlineLayout. - Align items to the first text baseline when it is set. --- .changeset/tall-donkeys-attend.md | 5 +++++ packages/ui/src/components/InlineLayout/index.tsx | 3 ++- packages/ui/src/components/InlineLayout/styles.module.css | 4 ++++ 3 files changed, 11 insertions(+), 1 deletion(-) create mode 100644 .changeset/tall-donkeys-attend.md diff --git a/.changeset/tall-donkeys-attend.md b/.changeset/tall-donkeys-attend.md new file mode 100644 index 0000000000..b3f4e61067 --- /dev/null +++ b/.changeset/tall-donkeys-attend.md @@ -0,0 +1,5 @@ +--- +"@ifrc-go/ui": minor +--- + +Add a `baseline` option to the `contentAlignment` prop of `InlineLayout`, so a leading icon or marker can sit on the first text baseline instead of the vertical centre. diff --git a/packages/ui/src/components/InlineLayout/index.tsx b/packages/ui/src/components/InlineLayout/index.tsx index 2f124c75eb..1e710ab5d1 100644 --- a/packages/ui/src/components/InlineLayout/index.tsx +++ b/packages/ui/src/components/InlineLayout/index.tsx @@ -29,7 +29,7 @@ export interface Props extends Omit, 'ref' | 'be withAdditionalInlinePadding?: boolean; withEllipsizedContent?: boolean; - contentAlignment?: 'start' | 'center' | 'end'; + contentAlignment?: 'start' | 'center' | 'end' | 'baseline'; contentJustification?: 'start' | 'center' | 'end'; withInlineDisplay?: boolean; } @@ -89,6 +89,7 @@ function InlineLayout(props: Props) { spacingClassName, contentAlignment === 'start' && styles.startAlignedContent, contentAlignment === 'end' && styles.endAlignedContent, + contentAlignment === 'baseline' && styles.baselineAlignedContent, withInlineDisplay && styles.withInlineDisplay, className, )} diff --git a/packages/ui/src/components/InlineLayout/styles.module.css b/packages/ui/src/components/InlineLayout/styles.module.css index e4ed19fa50..39235dd5f8 100644 --- a/packages/ui/src/components/InlineLayout/styles.module.css +++ b/packages/ui/src/components/InlineLayout/styles.module.css @@ -6,6 +6,10 @@ align-items: start; } + &.baseline-aligned-content { + align-items: baseline; + } + &.end-aligned-content { align-items: end; } From 1a09ccb90eab3545803814c27fc4e3396918df5c Mon Sep 17 00:00:00 2001 From: frozenhelium Date: Tue, 25 Aug 2026 03:12:44 +0545 Subject: [PATCH 2/2] feat(dref): add DREF landing page - Replace the DREF process, DREF detail and Early Action Protocols pages with a single DREF page under Respond. - Add an anticipatory pillar with imminent DREF and Early Action Protocols tabs, and a response pillar. - Add the DREF decision tree and open it from the navigation bar and from each pillar. - Seed a new DREF application from the decision tree outcomes and the pillar entry points. - Add operations and EAP maps and tables, FAQ sections and key DREF resources. - Apply the August 2026 content revision across both pillars. --- .changeset/lucky-pandas-marry.md | 11 + app/src/App/routes/index.tsx | 38 +- app/src/components/Navbar/i18n.json | 11 +- app/src/components/Navbar/index.tsx | 46 +- .../domain/CountryPointsMap/index.tsx | 180 ++ .../domain/DrefDecisionTree/engine.test.ts | 188 ++ .../domain/DrefDecisionTree/engine.ts | 94 + .../domain/DrefDecisionTree/i18n.json | 49 + .../domain/DrefDecisionTree/index.tsx | 402 ++++ .../domain/DrefDecisionTree/styles.module.css | 47 + .../domain/DrefDecisionTree/tree.ts | 306 +++ .../domain/DrefDecisionTree/types.ts | 75 + .../domain/DrefDecisionTree/validate.ts | 79 + .../domain/DrefDecisionTreeButton/i18n.json | 6 + .../domain/DrefDecisionTreeButton/index.tsx | 52 + .../domain/DrefDecisionTreeCallout/i18n.json | 7 + .../domain/DrefDecisionTreeCallout/index.tsx | 33 + .../DrefDecisionTreeCallout/styles.module.css | 4 + .../domain/DrefDocumentLink/index.tsx | 51 + .../domain/DrefKeyResources/i18n.json | 19 + .../domain/DrefKeyResources/index.tsx | 123 + app/src/components/domain/Faq/index.tsx | 45 + app/src/utils/constants.ts | 2 + app/src/utils/domain/dref.ts | 57 + app/src/views/Dref/i18n.json | 11 + app/src/views/Dref/index.tsx | 101 + .../DrefAnticipatoryPillar/EapMap/i18n.json | 8 + .../DrefAnticipatoryPillar/EapMap/index.tsx | 108 + .../DrefAnticipatoryPillar/EapTable/i18n.json | 13 + .../DrefAnticipatoryPillar/EapTable/index.tsx | 186 ++ .../ImminentDrefMap/i18n.json | 10 + .../ImminentDrefMap/index.tsx | 137 ++ .../ImminentDrefTable/i18n.json | 15 + .../ImminentDrefTable/index.tsx | 225 ++ .../views/DrefAnticipatoryPillar/i18n.json | 128 + .../views/DrefAnticipatoryPillar/index.tsx | 382 +++ app/src/views/DrefApplicationForm/index.tsx | 30 +- app/src/views/DrefDetail/i18n.json | 15 - app/src/views/DrefDetail/index.tsx | 57 - app/src/views/DrefProcess/i18n.json | 9 - app/src/views/DrefProcess/index.tsx | 36 - .../DrefOperationsMap/i18n.json | 9 + .../DrefOperationsMap/index.tsx | 121 + .../DrefOperationsTable/i18n.json | 15 + .../DrefOperationsTable/index.tsx | 217 ++ app/src/views/DrefResponsePillar/i18n.json | 99 + app/src/views/DrefResponsePillar/index.tsx | 276 +++ .../DrefResponsePillar/styles.module.css | 47 + app/src/views/EarlyActionProtocols/i18n.json | 14 - app/src/views/EarlyActionProtocols/index.tsx | 70 - .../000089-1787634374191.json | 2094 +++++++++++++++++ 51 files changed, 6124 insertions(+), 234 deletions(-) create mode 100644 .changeset/lucky-pandas-marry.md create mode 100644 app/src/components/domain/CountryPointsMap/index.tsx create mode 100644 app/src/components/domain/DrefDecisionTree/engine.test.ts create mode 100644 app/src/components/domain/DrefDecisionTree/engine.ts create mode 100644 app/src/components/domain/DrefDecisionTree/i18n.json create mode 100644 app/src/components/domain/DrefDecisionTree/index.tsx create mode 100644 app/src/components/domain/DrefDecisionTree/styles.module.css create mode 100644 app/src/components/domain/DrefDecisionTree/tree.ts create mode 100644 app/src/components/domain/DrefDecisionTree/types.ts create mode 100644 app/src/components/domain/DrefDecisionTree/validate.ts create mode 100644 app/src/components/domain/DrefDecisionTreeButton/i18n.json create mode 100644 app/src/components/domain/DrefDecisionTreeButton/index.tsx create mode 100644 app/src/components/domain/DrefDecisionTreeCallout/i18n.json create mode 100644 app/src/components/domain/DrefDecisionTreeCallout/index.tsx create mode 100644 app/src/components/domain/DrefDecisionTreeCallout/styles.module.css create mode 100644 app/src/components/domain/DrefDocumentLink/index.tsx create mode 100644 app/src/components/domain/DrefKeyResources/i18n.json create mode 100644 app/src/components/domain/DrefKeyResources/index.tsx create mode 100644 app/src/components/domain/Faq/index.tsx create mode 100644 app/src/views/Dref/i18n.json create mode 100644 app/src/views/Dref/index.tsx create mode 100644 app/src/views/DrefAnticipatoryPillar/EapMap/i18n.json create mode 100644 app/src/views/DrefAnticipatoryPillar/EapMap/index.tsx create mode 100644 app/src/views/DrefAnticipatoryPillar/EapTable/i18n.json create mode 100644 app/src/views/DrefAnticipatoryPillar/EapTable/index.tsx create mode 100644 app/src/views/DrefAnticipatoryPillar/ImminentDrefMap/i18n.json create mode 100644 app/src/views/DrefAnticipatoryPillar/ImminentDrefMap/index.tsx create mode 100644 app/src/views/DrefAnticipatoryPillar/ImminentDrefTable/i18n.json create mode 100644 app/src/views/DrefAnticipatoryPillar/ImminentDrefTable/index.tsx create mode 100644 app/src/views/DrefAnticipatoryPillar/i18n.json create mode 100644 app/src/views/DrefAnticipatoryPillar/index.tsx delete mode 100644 app/src/views/DrefDetail/i18n.json delete mode 100644 app/src/views/DrefDetail/index.tsx delete mode 100644 app/src/views/DrefProcess/i18n.json delete mode 100644 app/src/views/DrefProcess/index.tsx create mode 100644 app/src/views/DrefResponsePillar/DrefOperationsMap/i18n.json create mode 100644 app/src/views/DrefResponsePillar/DrefOperationsMap/index.tsx create mode 100644 app/src/views/DrefResponsePillar/DrefOperationsTable/i18n.json create mode 100644 app/src/views/DrefResponsePillar/DrefOperationsTable/index.tsx create mode 100644 app/src/views/DrefResponsePillar/i18n.json create mode 100644 app/src/views/DrefResponsePillar/index.tsx create mode 100644 app/src/views/DrefResponsePillar/styles.module.css delete mode 100644 app/src/views/EarlyActionProtocols/i18n.json delete mode 100644 app/src/views/EarlyActionProtocols/index.tsx create mode 100644 translationMigrations/000089-1787634374191.json diff --git a/.changeset/lucky-pandas-marry.md b/.changeset/lucky-pandas-marry.md new file mode 100644 index 0000000000..ae34d4521e --- /dev/null +++ b/.changeset/lucky-pandas-marry.md @@ -0,0 +1,11 @@ +--- +"go-web-app": minor +--- + +Add DREF landing page + +- Add a page for DREF process under Respond +- Add an anticipatory pillar with imminent DREF and Early Action Protocols tabs, and a response pillar +- Add the DREF decision tree, accessible from navigation bar and from each pillar +- Add option to create a new DREF application from the decision tree outcomes and the pillar entry points +- Add operations and EAP maps and tables, FAQ sections and key DREF resources diff --git a/app/src/App/routes/index.tsx b/app/src/App/routes/index.tsx index d3cceb192e..6d9239cb14 100644 --- a/app/src/App/routes/index.tsx +++ b/app/src/App/routes/index.tsx @@ -319,46 +319,46 @@ const emergencyAdditionalInfo = customWrapRoute({ }, }); -type DefaultDrefDetailChild = 'dref-detail'; -const drefProcessLayout = customWrapRoute({ +type DefaultDrefPillarChild = 'response-pillar'; +const drefLayout = customWrapRoute({ parent: rootLayout, - path: 'dref-process', - forwardPath: 'dref-detail' satisfies DefaultDrefDetailChild, + path: 'dref', + forwardPath: 'response-pillar' satisfies DefaultDrefPillarChild, component: { - render: () => import('#views/DrefProcess'), + render: () => import('#views/Dref'), props: {}, }, wrapperComponent: Auth, context: { - title: 'DREF Process', + title: 'Disaster Response Emergency Fund (DREF)', visibility: 'anything', }, }); -const drefDetail = customWrapRoute({ - parent: drefProcessLayout, - path: 'dref-detail' satisfies DefaultDrefDetailChild, +const drefResponsePillar = customWrapRoute({ + parent: drefLayout, + path: 'response-pillar' satisfies DefaultDrefPillarChild, component: { - render: () => import('#views/DrefDetail'), + render: () => import('#views/DrefResponsePillar'), props: {}, }, wrapperComponent: Auth, context: { - title: 'Response and Imminent DREF', + title: 'Response Pillar', visibility: 'anything', }, }); -const eapDetail = customWrapRoute({ - parent: drefProcessLayout, - path: 'eap-detail', +const drefAnticipatoryPillar = customWrapRoute({ + parent: drefLayout, + path: 'anticipatory-pillar', component: { - render: () => import('#views/EarlyActionProtocols'), + render: () => import('#views/DrefAnticipatoryPillar'), props: {}, }, wrapperComponent: Auth, context: { - title: 'Early Action Protocols', + title: 'Anticipatory Pillar', visibility: 'anything', }, }); @@ -1541,9 +1541,9 @@ const wrappedRoutes = { // Redirects preparednessOperationalLearning, obsoleteFieldReportDetails, - drefDetail, - eapDetail, - drefProcessLayout, + drefLayout, + drefResponsePillar, + drefAnticipatoryPillar, eapRegistrationLayout, eapDevelopmentRegistrationForm, eapFullExport, diff --git a/app/src/components/Navbar/i18n.json b/app/src/components/Navbar/i18n.json index e0ed399edb..ffa0cb7578 100644 --- a/app/src/components/Navbar/i18n.json +++ b/app/src/components/Navbar/i18n.json @@ -29,7 +29,7 @@ "userMenuEmergencies":"Emergencies", "userMenuEmergenciesDescription": "Follow currently ongoing emergencies, as well as access the list of previous emergencies or IFRC-led operations.", "userMenuEarlyWarning":"Early Warning", - "userMenuDrefProcess":"DREF Process ", + "userMenuDrefProcess":"Disaster Response Emergency Fund (DREF)", "userMenuSurgeDeployments":"Surge/Deployments", "userMenuOngoingEmergencies":"Ongoing Emergencies", "userMenuCreateFieldReport":"Create Field Report", @@ -37,10 +37,13 @@ "userMenuEarlyWarningDescription":"Early Warning focuses on preparatory action ahead of possible disasters and events. Use one of the following links to submit information on early warning.", "userMenuCreateEarlyActionFieldReport":"Create Early Action Field Report", "userMenuCreateFlashUpdate":"Create Flash Update", - "userMenuDrefProcessDescription":"Disaster Response Emergency Fund (DREF) is the quickest way of getting funding directly to local humanitarian actors. Use one of the links below to submit a DREF Application or an update.", + "userMenuDrefProcessDescription":"The following are IFRC Applications that include Disaster Response Emergency Fund (DREF) and Early Action Protocols (EAP).", "userMenuCreateDrefApplication":"Create DREF Application", - "myDrefApplications": "My DREF Applications", - "earlyActionProtocols": "Early Action Protocols (EAP)", + "userMenuDrefDecisionTree":"DREF Decision Tree", + "userMenuDrefAnticipatoryPillar":"Anticipatory Pillar", + "userMenuDrefResponsePillar":"Response Pillar", + "myDrefApplications":"My DREF Applications", + "earlyActionProtocols":"Early Action Protocols (EAP)", "userMenuSurge":"The section displays the summary of deployments within current and ongoing emergencies. Login to see available details", "userMenuSurgeGlobalOverview":"Surge Global Overview", "userMenuOperationalToolbox":"Operational Toolbox", diff --git a/app/src/components/Navbar/index.tsx b/app/src/components/Navbar/index.tsx index 91a47f0ca9..b406944244 100644 --- a/app/src/components/Navbar/index.tsx +++ b/app/src/components/Navbar/index.tsx @@ -334,17 +334,45 @@ function Navbar(props: Props) { name="dref-process" description={strings.userMenuDrefProcessDescription} footer={( - - {strings.userMenuCreateDrefApplication} - + <> + + {strings.userMenuCreateDrefApplication} + + + {strings.userMenuDrefDecisionTree} + + )} > + + {strings.userMenuDrefAnticipatoryPillar} + + + {strings.userMenuDrefResponsePillar} + = { + type: 'circle', + paint: pointPaint, +}; + +export interface CountryPoint { + iso3: string; + color: string; +} + +export interface MapLegendOption { + value: string | number; + label: string; + color: string; +} + +interface ClickedPoint { + featureProperties: AdminZeroFeatureProperties; + lngLat: mapboxgl.LngLatLike; +} + +interface Props { + className?: string; + mapTitle: string; + points: CountryPoint[]; + // Optional — omit (or pass empty) to render no legend. + legendOptions?: MapLegendOption[]; + // Popup content for a clicked country that has a point. + renderPopup: (iso3: string) => ReactNode; +} + +function CountryPointsMap(props: Props) { + const { + className, + mapTitle, + points, + legendOptions, + renderPopup, + } = props; + + const countryResponse = useCountryRaw(); + const [clickedPoint, setClickedPoint] = useState(); + + const colorByIso3 = useMemo( + () => listToMap(points, (point) => point.iso3, (point) => point.color), + [points], + ); + + const geoJson = useMemo>( + () => ({ + type: 'FeatureCollection', + features: (countryResponse ?? []) + .map((country) => { + if (isNotDefined(country.centroid) || isNotDefined(country.iso3)) { + return undefined; + } + const color = colorByIso3[country.iso3]; + if (isNotDefined(color)) { + return undefined; + } + return { + type: 'Feature' as const, + geometry: country.centroid as { + type: 'Point'; + coordinates: [number, number]; + }, + properties: { + id: country.iso3, + color, + }, + }; + }) + .filter(isDefined), + }), + [countryResponse, colorByIso3], + ); + + const handleCountryClick = useCallback( + (featureProperties: AdminZeroFeatureProperties, lngLat: mapboxgl.LngLatLike) => { + if (isDefined(colorByIso3[featureProperties.iso3])) { + setClickedPoint({ featureProperties, lngLat }); + } + return true; + }, + [colorByIso3], + ); + + const handlePointClose = useCallback(() => setClickedPoint(undefined), []); + + const hasLegend = isDefined(legendOptions) && legendOptions.length > 0; + + return ( + + + {legendOptions.map((legendItem) => ( + + ))} + + ) : undefined} + /> + + + + {clickedPoint?.lngLat && ( + + {clickedPoint.featureProperties.name} + + )} + withPadding + > + {renderPopup(clickedPoint.featureProperties.iso3)} + + )} + + ); +} + +export default CountryPointsMap; diff --git a/app/src/components/domain/DrefDecisionTree/engine.test.ts b/app/src/components/domain/DrefDecisionTree/engine.test.ts new file mode 100644 index 0000000000..70f6a61a14 --- /dev/null +++ b/app/src/components/domain/DrefDecisionTree/engine.test.ts @@ -0,0 +1,188 @@ +import { + describe, + expect, + test, +} from 'vitest'; + +import { + DISASTER_TYPE_DROUGHT, + DREF_TYPE_ASSESSMENT, + DREF_TYPE_IMMINENT, + DREF_TYPE_RESPONSE, + ONSET_SLOW, + ONSET_SUDDEN, +} from '#utils/constants'; + +import { + answer, + resolve, +} from './engine'; +import drefDecisionTree from './tree'; +import { type AnswerPath } from './types'; +import { + getTreeErrors, + validateTree, +} from './validate'; + +// Apply a sequence of option values from the root. +function walk(values: string[]): AnswerPath { + return values.reduce( + (path, value) => answer(drefDecisionTree, path, value), + [], + ); +} + +describe('decision tree structure', () => { + test('has no structural errors', () => { + expect(getTreeErrors(drefDecisionTree)).toEqual([]); + }); + + test('every branch reaches an outcome', () => { + const gaps = validateTree(drefDecisionTree) + .filter((issue) => issue.message.includes('gap')); + expect(gaps).toEqual([]); + }); + + test('no node is unreachable', () => { + const unreachable = validateTree(drefDecisionTree) + .filter((issue) => issue.message.includes('unreachable')); + expect(unreachable).toEqual([]); + }); +}); + +describe('traversal -> outcomes', () => { + test('occurred, sudden, large -> Emergency Appeal', () => { + const { outcome } = resolve(drefDecisionTree, walk(['yes', 'sudden', 'large'])); + expect(outcome?.outcomeKey).toBe('outcome.emergencyAppeal'); + }); + + test('occurred, sudden, small, enough info -> Response DREF', () => { + const { outcome } = resolve(drefDecisionTree, walk(['yes', 'sudden', 'small', 'yes'])); + expect(outcome?.outcomeKey).toBe('outcome.responseDref'); + }); + + test('occurred, sudden, small, not enough info -> Assessment DREF', () => { + const { outcome } = resolve(drefDecisionTree, walk(['yes', 'sudden', 'small', 'no'])); + expect(outcome?.outcomeKey).toBe('outcome.assessmentDref'); + }); + + test('occurred, slow, drought -> Drought DREF', () => { + const { outcome } = resolve(drefDecisionTree, walk(['yes', 'slow', 'yes'])); + expect(outcome?.outcomeKey).toBe('outcome.droughtDref'); + }); + + test('not occurred, EAP in place, trigger reached -> EAP Activation', () => { + const { outcome } = resolve(drefDecisionTree, walk(['no', 'yes', 'yes'])); + expect(outcome?.outcomeKey).toBe('outcome.eapActivation'); + }); + + test('not occurred, EAP in place, risk and coverage match -> exceptional approval', () => { + const { outcome } = resolve(drefDecisionTree, walk(['no', 'yes', 'no', 'yes', 'yes'])); + expect(outcome?.outcomeKey).toBe('outcome.exceptionalApproval'); + }); + + test('not occurred, EAP in place, risk below threshold -> Imminent DREF', () => { + const { outcome } = resolve(drefDecisionTree, walk(['no', 'yes', 'no', 'no'])); + expect(outcome?.outcomeKey).toBe('outcome.imminentDref'); + }); + + test('not occurred, EAP in place, coverage differs -> Imminent DREF', () => { + const { outcome } = resolve(drefDecisionTree, walk(['no', 'yes', 'no', 'yes', 'no'])); + expect(outcome?.outcomeKey).toBe('outcome.imminentDref'); + }); + + test('not occurred, no EAP, no alert -> develop an EAP', () => { + const { outcome } = resolve(drefDecisionTree, walk(['no', 'no', 'no'])); + expect(outcome?.outcomeKey).toBe('outcome.developEap'); + }); + + test('not occurred, no EAP, alert not readiness-related -> Imminent DREF', () => { + const { outcome } = resolve(drefDecisionTree, walk(['no', 'no', 'yes', 'no'])); + expect(outcome?.outcomeKey).toBe('outcome.imminentDref'); + }); + + test('not occurred, no EAP, readiness alert, drought -> Drought DREF', () => { + const { outcome } = resolve(drefDecisionTree, walk(['no', 'no', 'yes', 'yes', 'yes'])); + expect(outcome?.outcomeKey).toBe('outcome.droughtDref'); + }); + + test('not occurred, no EAP, readiness alert, not drought -> Response DREF', () => { + const { outcome } = resolve(drefDecisionTree, walk(['no', 'no', 'yes', 'yes', 'no'])); + expect(outcome?.outcomeKey).toBe('outcome.responseDref'); + }); +}); + +describe('outcome form seeding', () => { + test('sudden Response DREF seeds response type and sudden onset', () => { + const { outcome } = resolve(drefDecisionTree, walk(['yes', 'sudden', 'small', 'yes'])); + expect(outcome?.actions[0]).toMatchObject({ + type: 'navigate', + route: 'newDrefApplicationForm', + state: { type_of_dref: DREF_TYPE_RESPONSE, type_of_onset: ONSET_SUDDEN }, + }); + }); + + test('Assessment DREF seeds the assessment type', () => { + const { outcome } = resolve(drefDecisionTree, walk(['yes', 'sudden', 'small', 'no'])); + expect(outcome?.actions[0]).toMatchObject({ + state: { type_of_dref: DREF_TYPE_ASSESSMENT, type_of_onset: ONSET_SUDDEN }, + }); + }); + + test('Drought DREF seeds the drought disaster type and slow onset', () => { + const { outcome } = resolve(drefDecisionTree, walk(['yes', 'slow', 'yes'])); + expect(outcome?.actions[0]).toMatchObject({ + state: { + type_of_dref: DREF_TYPE_RESPONSE, + type_of_onset: ONSET_SLOW, + disaster_type: DISASTER_TYPE_DROUGHT, + }, + }); + }); + + test('Imminent DREF seeds the imminent type', () => { + const { outcome } = resolve(drefDecisionTree, walk(['no', 'no', 'yes', 'no'])); + expect(outcome?.actions[0]).toMatchObject({ + state: { type_of_dref: DREF_TYPE_IMMINENT }, + }); + }); + + test('develop-an-EAP routes to the EAP registration form', () => { + const { outcome } = resolve(drefDecisionTree, walk(['no', 'no', 'no'])); + expect(outcome?.actions[0]).toMatchObject({ + type: 'navigate', + route: 'newEapDevelopmentRegistration', + }); + }); +}); + +describe('outcome guidance', () => { + test('the two Response DREF leaves point at different guidance', () => { + const slow = resolve(drefDecisionTree, walk(['yes', 'slow', 'no'])).outcome; + const readiness = resolve(drefDecisionTree, walk(['no', 'no', 'yes', 'yes', 'no'])).outcome; + + const slowGuidance = slow?.actions.find((action) => action.type === 'external'); + const readinessGuidance = readiness?.actions.find((action) => action.type === 'external'); + + expect(slowGuidance).toBeDefined(); + expect(readinessGuidance).toBeDefined(); + expect(slowGuidance).not.toEqual(readinessGuidance); + }); + + test('Emergency Appeal is advisory only and carries a resources link', () => { + const { outcome } = resolve(drefDecisionTree, walk(['yes', 'sudden', 'large'])); + expect(outcome?.actions).toEqual([]); + expect(outcome?.notes?.[0]?.link?.url).toBeTruthy(); + }); + + test('the sudden Response DREF carries advance-payment and recurrent-event guidance', () => { + const { outcome } = resolve(drefDecisionTree, walk(['yes', 'sudden', 'small', 'yes'])); + expect(outcome?.notes?.map((note) => note.textKey)).toEqual([ + 'note.advancePayment', + 'note.recurrentEvents', + ]); + outcome?.notes?.forEach((note) => { + expect(note.link?.url).toBeTruthy(); + }); + }); +}); diff --git a/app/src/components/domain/DrefDecisionTree/engine.ts b/app/src/components/domain/DrefDecisionTree/engine.ts new file mode 100644 index 0000000000..8dc6b4201d --- /dev/null +++ b/app/src/components/domain/DrefDecisionTree/engine.ts @@ -0,0 +1,94 @@ +import { isNotDefined } from '@togglecorp/fujs'; + +import { + type AnswerPath, + type ContentKey, + type DecisionTree, + type NodeId, + type Option, + type OutcomeNode, + type QuestionNode, + type TreeNode, +} from './types'; + +interface ResolvedStep { + nodeId: NodeId; + questionKey: ContentKey; + selectedValue: string; + selectedLabelKey: ContentKey; + noteKey?: ContentKey; +} + +interface ResolvedState { + // Answered questions, in order — drives the cumulative view from the wireframe. + steps: ResolvedStep[]; + // The next unanswered question, if the path has not terminated. + activeNodeId?: NodeId; + activeQuestion?: QuestionNode; + // The terminal recommendation, if the path reached one. + outcome?: OutcomeNode; + // True when the path ran into an undefined branch (`next === null`). + isDeadEnd: boolean; +} + +// Walk the answer path from the root and derive everything the UI renders. Pure. +// Tolerant of a stale path (e.g. after the tree is edited): it stops at the first +// step that no longer matches rather than throwing. +export function resolve(tree: DecisionTree, path: AnswerPath): ResolvedState { + const steps: ResolvedStep[] = []; + let currentId: NodeId | null = tree.root; + + for (let i = 0; i < path.length; i += 1) { + const step = path[i]; + if (isNotDefined(step) || isNotDefined(currentId)) { + break; + } + const node: TreeNode | undefined = tree.nodes[currentId]; + if (isNotDefined(node) || node.kind !== 'question' || currentId !== step.nodeId) { + break; + } + const option: Option | undefined = node.options.find((opt) => opt.value === step.value); + if (isNotDefined(option)) { + break; + } + steps.push({ + nodeId: step.nodeId, + questionKey: node.questionKey, + selectedValue: option.value, + selectedLabelKey: option.labelKey, + noteKey: option.noteKey, + }); + currentId = option.next; + } + + if (isNotDefined(currentId)) { + return { steps, isDeadEnd: true }; + } + + const node = tree.nodes[currentId]; + if (isNotDefined(node)) { + return { steps, isDeadEnd: true }; + } + if (node.kind === 'outcome') { + return { steps, outcome: node, isDeadEnd: false }; + } + return { + steps, + activeNodeId: currentId, + activeQuestion: node, + isDeadEnd: false, + }; +} + +// Answer the currently-active question; returns a new path. No-op if no active question. +export function answer(tree: DecisionTree, path: AnswerPath, value: string): AnswerPath { + const { activeNodeId } = resolve(tree, path); + if (isNotDefined(activeNodeId)) { + return path; + } + return [...path, { nodeId: activeNodeId, value }]; +} + +export function restart(): AnswerPath { + return []; +} diff --git a/app/src/components/domain/DrefDecisionTree/i18n.json b/app/src/components/domain/DrefDecisionTree/i18n.json new file mode 100644 index 0000000000..3e2cedd89a --- /dev/null +++ b/app/src/components/domain/DrefDecisionTree/i18n.json @@ -0,0 +1,49 @@ +{ + "namespace": "drefDecisionTree", + "strings": { + "title": "DREF DECISION TREE - DREF FUNDING OPTIONS", + "disclaimer": "For guidance purposes only, and under consideration that both the National Society and the disaster are eligible for DREF. Always coordinate with your Delegation and DREF Focal Point.", + "restartButton": "Restart", + "nextButton": "Next", + "backButton": "Back", + "deadEndMessage": "No recommendation is configured for this path yet. Please coordinate with your Delegation and DREF Focal Point.", + "drefApplicationFormButton": "DREF Application Form", + "drefGuidelinesButton": "DREF Guidelines", + "eapDevelopmentRegistrationButton": "Early Action Protocol Development Registration", + "questionEventOccurred": "Has the event already occurred?", + "questionNature": "What is the nature of the disaster?", + "questionSize": "What size of operation are you aiming at?", + "questionEnoughInfo": "Do you have enough information to justify the response?", + "questionDroughtFocusResponse": "Are you responding specifically to drought, food insecurity, or water shortages?", + "questionDroughtFocusAnticipatory": "Are you anticipating specifically the impacts of drought, food insecurity, or water shortages?", + "questionHasEap": "Does the National Society have an Early Action Protocol in place?", + "questionEapTrigger": "Has the pre-agreed trigger of the EAP been reached?", + "questionRiskThreshold": "Is the level of risk similar to the EAP threshold?", + "questionGeoCoverage": "Is the geographical coverage the same as indicated in the EAP?", + "questionAlertIssued": "Has an alert been issued?", + "questionAlertRelated": "Is the alert related to a slow-onset hazard, civil unrest, election readiness or epidemic?", + "optionYes": "Yes", + "optionNo": "No", + "optionNatureSudden": "Sudden Onset Emergency", + "optionNatureSlow": "Slow Onset Emergency", + "optionSizeLarge": "Large-scale emergency requiring broader support", + "optionSizeSmall": "Small/medium-scale emergency", + "noteEmergencyAppealUnavailable": "Please note that currently Emergency Appeals cannot be done through the IFRC GO platform.", + "noteAdvancePayment": "As this is a sudden-onset event, your National Society may also request an advance payment while developing the DREF Application.", + "noteRecurrentEvents": "For recurrent events, your National Society may need to provide additional information or justification for the use of DREF.", + "noteConductAssessment": "If not using the Assessment-type DREF Application form, conduct a further assessment before applying for DREF.", + "noteInsufficientEvidence": "If evidence is insufficient to justify a full response, consider an Assessment DREF allocation first to generate the necessary evidence before scaling up the intervention.", + "noteEapActivationByEmail": "Please note that currently the EAP Activation process cannot be done through the IFRC GO platform. Kindly submit your activation notification through the following email address: dref.anticipatorypillar@ifrc.org", + "noteJustifyExceptionalApproval": "Make sure to include all the necessary information to justify the exceptional approval.", + "noteLinkLearnMore": "Click here to learn more.", + "noteLinkFollowingResources": "Check the following resources for more details.", + "outcomeResponseDref": "Consider Response DREF", + "outcomeAssessmentDref": "Consider Assessment DREF", + "outcomeDroughtDref": "Consider Response DREF focused on Drought disaster type", + "outcomeImminentDref": "Consider Imminent DREF", + "outcomeEapActivation": "Consider EAP Activation", + "outcomeExceptionalApproval": "Potentially eligible for exceptional approval for the EAP Activation", + "outcomeEmergencyAppeal": "Consider Emergency Appeal", + "outcomeDevelopEap": "Consider developing an Early Action Protocol" + } +} diff --git a/app/src/components/domain/DrefDecisionTree/index.tsx b/app/src/components/domain/DrefDecisionTree/index.tsx new file mode 100644 index 0000000000..e16c88d6e3 --- /dev/null +++ b/app/src/components/domain/DrefDecisionTree/index.tsx @@ -0,0 +1,402 @@ +import { + type ComponentProps, + useCallback, + useMemo, + useState, +} from 'react'; +import { + Button, + ButtonLayout, + Description, + InlineLayout, + ListView, + Modal, + RadioInput, + RawButton, +} from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; +import { + isDefined, + isNotDefined, +} from '@togglecorp/fujs'; + +import Link from '#components/Link'; + +import { + answer, + resolve, + restart, +} from './engine'; +import drefDecisionTree from './tree'; +import { + type AnswerPath, + type ContentKey, + type Option, +} from './types'; + +import i18n from './i18n.json'; +import styles from './styles.module.css'; + +const optionKeySelector = (option: Option) => option.value; + +interface LayoutProps { + children: React.ReactNode; + hasSummary: boolean; +} + +function BodyLayout(props: LayoutProps) { + const { + hasSummary, + children, + } = props; + + if (hasSummary) { + return ( + + {children} + + ); + } + + return ( + + {children} + + ); +} + +interface Props { + onClose: () => void; +} + +function DrefDecisionTreeModal(props: Props) { + const { onClose } = props; + const strings = useTranslation(i18n); + + // Abstract content key -> translated string. Kept in this index.tsx (not in tree.ts) so the + // i18n-usage lint rule — which only scans the co-located index.tsx — sees every key as used. + const content = useMemo>( + () => ({ + 'q.eventOccurred': strings.questionEventOccurred, + 'q.nature': strings.questionNature, + 'q.size': strings.questionSize, + 'q.enoughInfo': strings.questionEnoughInfo, + 'q.droughtFocusResponse': strings.questionDroughtFocusResponse, + 'q.droughtFocusAnticipatory': strings.questionDroughtFocusAnticipatory, + 'q.hasEap': strings.questionHasEap, + 'q.eapTrigger': strings.questionEapTrigger, + 'q.riskThreshold': strings.questionRiskThreshold, + 'q.geoCoverage': strings.questionGeoCoverage, + 'q.alertIssued': strings.questionAlertIssued, + 'q.alertRelated': strings.questionAlertRelated, + + 'opt.nature.sudden': strings.optionNatureSudden, + 'opt.nature.slow': strings.optionNatureSlow, + 'opt.size.large': strings.optionSizeLarge, + 'opt.size.small': strings.optionSizeSmall, + 'opt.yes': strings.optionYes, + 'opt.no': strings.optionNo, + + 'note.emergencyAppealUnavailable': strings.noteEmergencyAppealUnavailable, + 'note.advancePayment': strings.noteAdvancePayment, + 'note.recurrentEvents': strings.noteRecurrentEvents, + 'note.conductAssessment': strings.noteConductAssessment, + 'note.insufficientEvidence': strings.noteInsufficientEvidence, + 'note.eapActivationByEmail': strings.noteEapActivationByEmail, + 'note.justifyExceptionalApproval': strings.noteJustifyExceptionalApproval, + 'note.link.learnMore': strings.noteLinkLearnMore, + 'note.link.followingResources': strings.noteLinkFollowingResources, + + 'outcome.responseDref': strings.outcomeResponseDref, + 'outcome.assessmentDref': strings.outcomeAssessmentDref, + 'outcome.droughtDref': strings.outcomeDroughtDref, + 'outcome.imminentDref': strings.outcomeImminentDref, + 'outcome.eapActivation': strings.outcomeEapActivation, + 'outcome.exceptionalApproval': strings.outcomeExceptionalApproval, + 'outcome.emergencyAppeal': strings.outcomeEmergencyAppeal, + 'outcome.developEap': strings.outcomeDevelopEap, + + 'cta.drefApplicationForm': strings.drefApplicationFormButton, + 'cta.drefGuidelines': strings.drefGuidelinesButton, + 'cta.eapDevelopmentRegistration': strings.eapDevelopmentRegistrationButton, + }), + [strings], + ); + + const t = useCallback( + (key: ContentKey | undefined): string => (isDefined(key) ? (content[key] ?? key) : ''), + [content], + ); + + const [path, setPath] = useState([]); + // The option chosen for the active question, not yet committed (committed on "Next"). + const [selectedValue, setSelectedValue] = useState(undefined); + + const state = useMemo(() => resolve(drefDecisionTree, path), [path]); + const { + steps, + activeQuestion, + outcome, + } = state; + + const handleNext = useCallback( + () => { + if (isNotDefined(selectedValue)) { + return; + } + setPath((prev) => answer(drefDecisionTree, prev, selectedValue)); + setSelectedValue(undefined); + }, + [selectedValue], + ); + + const handleBack = useCallback( + () => { + setPath((prev) => prev.slice(0, -1)); + setSelectedValue(undefined); + }, + [], + ); + + const handleJumpTo = useCallback( + (index: number) => { + setPath((prev) => prev.slice(0, index)); + setSelectedValue(undefined); + }, + [], + ); + + const handleRestart = useCallback( + () => { + setPath(restart()); + setSelectedValue(undefined); + }, + [], + ); + + const labelSelector = useCallback( + (option: Option) => t(option.labelKey), + [t], + ); + + const hasSummary = steps.length > 0; + + return ( + + {strings.restartButton} + + )} + onClose={onClose} + withHeaderBorder + size="auto" + className={styles.drefDecisionTree} + spacing="lg" + > + + {hasSummary && ( + + {steps.map((step, index) => ( + + + )} + contentAlignment="baseline" + spacing="xs" + > + +
+ {t(step.questionKey)} +
+
+ {t(step.selectedLabelKey)} +
+ {isDefined(step.noteKey) && ( + + {t(step.noteKey)} + + )} + + + + ))} + + )} + +
+ {isDefined(activeQuestion) && ( + +
+ {t(activeQuestion.questionKey)} +
+ + + + + {hasSummary && ( + + )} + + + + )} + {isDefined(outcome) && ( + <> +
+
+ + {t(outcome.outcomeKey)} + +
+ {outcome.notes?.map((note) => ( +

+ {t(note.textKey)} + {isDefined(note.link) && ( + <> +   + + {t(note.link.labelKey)} + + + )} +

+ ))} + + + {outcome.actions.map((action) => ( + action.type === 'navigate' ? ( + ['to']} + urlParams={action.urlParams} + state={action.state} + styleVariant="filled" + colorVariant="primary" + > + {t(action.labelKey ?? outcome.outcomeKey)} + + ) : ( + + {t(action.labelKey)} + + ) + ))} + + + )} + {state.isDeadEnd && isNotDefined(outcome) && ( + <> +

{strings.deadEndMessage}

+ {hasSummary && ( + + )} + + )} + + + + ); +} + +export default DrefDecisionTreeModal; diff --git a/app/src/components/domain/DrefDecisionTree/styles.module.css b/app/src/components/domain/DrefDecisionTree/styles.module.css new file mode 100644 index 0000000000..a52df992fb --- /dev/null +++ b/app/src/components/domain/DrefDecisionTree/styles.module.css @@ -0,0 +1,47 @@ +.dref-decision-tree { + --min-height: min(36rem, calc(100vh - 10rem)); + + .summary-section { + align-self: stretch; + min-height: var(--min-height); + border-inline-end: var(--go-ui-width-separator-thin) solid var(--go-ui-color-separator); + + .summary-step { + padding: 0 var(--go-ui-spacing-sm); + text-align: start; + font-size: var(--go-ui-font-size-sm); + + .details { + border-bottom: var(--go-ui-width-separator-thin) solid var(--go-ui-color-separator); + padding-block-end: var(--go-ui-spacing-2xs); + } + + &:hover { + .details { + border-bottom-color: var(--go-ui-color-primary-red); + } + } + + .circle { + border-radius: 50%; + background-color: var(--go-ui-color-primary-red); + width: 0.6rem; + aspect-ratio: 1; + } + + .summary-answer { + color: var(--go-ui-color-primary-red); + font-weight: var(--go-ui-font-weight-medium); + } + } + } + + .question-section { + min-height: var(--min-height); + + .active-question { + text-align: center; + font-size: var(--go-ui-font-size-2xl); + } + } +} diff --git a/app/src/components/domain/DrefDecisionTree/tree.ts b/app/src/components/domain/DrefDecisionTree/tree.ts new file mode 100644 index 0000000000..2eb81769b0 --- /dev/null +++ b/app/src/components/domain/DrefDecisionTree/tree.ts @@ -0,0 +1,306 @@ +import { + DISASTER_TYPE_DROUGHT, + DREF_TYPE_ASSESSMENT, + DREF_TYPE_IMMINENT, + DREF_TYPE_RESPONSE, + ONSET_SLOW, + ONSET_SUDDEN, +} from '#utils/constants'; +import { + DREF_GUIDELINES_ADVANCE_PAYMENT_URL, + DREF_GUIDELINES_DROUGHT_URL, + DREF_GUIDELINES_EAP_ACTIVATION_URL, + DREF_GUIDELINES_EAP_DEVELOPMENT_URL, + DREF_GUIDELINES_IMMINENT_URL, + DREF_GUIDELINES_READINESS_URL, + DREF_GUIDELINES_RECURRENT_EVENTS_URL, + DREF_GUIDELINES_RESPONSE_URL, + EMERGENCY_APPEAL_RESOURCES_URL, + getNewDrefRouteState, +} from '#utils/domain/dref'; + +import { + type DecisionTree, + type OutcomeAction, +} from './types'; + +// DREF DECISION TREE - DREF FUNDING OPTIONS +// +// Mirrors DREFDecisionTree_2026.08.24.pdf. Flat node graph: each question's option +// points (`next`) at another node id. Outcomes are shared only where BOTH the seeded +// form state and the guidance target match, which is why the two "Response DREF" and +// the two "Drought DREF" leaves are separate nodes: the slow-onset pair links to the +// allocation-parameters guidance, the anticipatory pair to readiness/drought guidance. +// Re-wiring the tree = editing `next` values here; re-wording it = editing i18n.json. +// +// Content keys (q.* / opt.* / note.* / outcome.* / cta.*) are resolved in index.tsx. +// `validateTree` (see validate.ts + engine.test.ts) guards the invariants on every edit. + +const drefApplicationForm = ( + state: ReturnType, +): OutcomeAction => ({ + type: 'navigate', + route: 'newDrefApplicationForm', + labelKey: 'cta.drefApplicationForm', + state, +}); + +const drefGuidelines = (url: string): OutcomeAction => ({ + type: 'external', + url, + labelKey: 'cta.drefGuidelines', +}); + +const drefDecisionTree: DecisionTree = { + root: 'eventOccurred', + nodes: { + // ----- Q1: entry ----- + eventOccurred: { + kind: 'question', + questionKey: 'q.eventOccurred', + options: [ + { value: 'yes', labelKey: 'opt.yes', next: 'natureOfDisaster' }, + { value: 'no', labelKey: 'opt.no', next: 'hasEap' }, + ], + }, + + // =================== Branch A - the event has already occurred =================== + natureOfDisaster: { + kind: 'question', + questionKey: 'q.nature', + options: [ + { value: 'sudden', labelKey: 'opt.nature.sudden', next: 'sizeOfOperation' }, + { value: 'slow', labelKey: 'opt.nature.slow', next: 'droughtFocusResponse' }, + ], + }, + + // --- sudden onset --- + sizeOfOperation: { + kind: 'question', + questionKey: 'q.size', + options: [ + { value: 'large', labelKey: 'opt.size.large', next: 'o_emergencyAppeal' }, + { value: 'small', labelKey: 'opt.size.small', next: 'enoughInfo' }, + ], + }, + enoughInfo: { + kind: 'question', + questionKey: 'q.enoughInfo', + options: [ + { value: 'yes', labelKey: 'opt.yes', next: 'o_responseDrefSudden' }, + { value: 'no', labelKey: 'opt.no', next: 'o_assessmentDref' }, + ], + }, + + // --- slow onset --- + droughtFocusResponse: { + kind: 'question', + questionKey: 'q.droughtFocusResponse', + options: [ + { value: 'yes', labelKey: 'opt.yes', next: 'o_droughtDrefSlow' }, + { value: 'no', labelKey: 'opt.no', next: 'o_responseDrefSlow' }, + ], + }, + + // =================== Branch B - the event has not occurred =================== + hasEap: { + kind: 'question', + questionKey: 'q.hasEap', + options: [ + { value: 'yes', labelKey: 'opt.yes', next: 'eapTriggerReached' }, + { value: 'no', labelKey: 'opt.no', next: 'alertIssued' }, + ], + }, + + // --- an EAP is in place --- + eapTriggerReached: { + kind: 'question', + questionKey: 'q.eapTrigger', + options: [ + { value: 'yes', labelKey: 'opt.yes', next: 'o_eapActivation' }, + { value: 'no', labelKey: 'opt.no', next: 'riskSimilarToThreshold' }, + ], + }, + riskSimilarToThreshold: { + kind: 'question', + questionKey: 'q.riskThreshold', + options: [ + { value: 'yes', labelKey: 'opt.yes', next: 'geoCoverageSame' }, + { value: 'no', labelKey: 'opt.no', next: 'o_imminentDref' }, + ], + }, + geoCoverageSame: { + kind: 'question', + questionKey: 'q.geoCoverage', + options: [ + { value: 'yes', labelKey: 'opt.yes', next: 'o_exceptionalApproval' }, + { value: 'no', labelKey: 'opt.no', next: 'o_imminentDref' }, + ], + }, + + // --- no EAP in place --- + alertIssued: { + kind: 'question', + questionKey: 'q.alertIssued', + options: [ + { value: 'yes', labelKey: 'opt.yes', next: 'alertRelatedToTypes' }, + { value: 'no', labelKey: 'opt.no', next: 'o_developEap' }, + ], + }, + alertRelatedToTypes: { + kind: 'question', + questionKey: 'q.alertRelated', + options: [ + { value: 'yes', labelKey: 'opt.yes', next: 'droughtFocusAnticipatory' }, + { value: 'no', labelKey: 'opt.no', next: 'o_imminentDref' }, + ], + }, + droughtFocusAnticipatory: { + kind: 'question', + questionKey: 'q.droughtFocusAnticipatory', + options: [ + { value: 'yes', labelKey: 'opt.yes', next: 'o_droughtDrefAnticipatory' }, + { value: 'no', labelKey: 'opt.no', next: 'o_responseDrefReadiness' }, + ], + }, + + // =================== Outcomes =================== + o_emergencyAppeal: { + kind: 'outcome', + outcomeKey: 'outcome.emergencyAppeal', + notes: [{ + textKey: 'note.emergencyAppealUnavailable', + link: { + url: EMERGENCY_APPEAL_RESOURCES_URL, + labelKey: 'note.link.followingResources', + }, + }], + actions: [], + }, + o_responseDrefSudden: { + kind: 'outcome', + outcomeKey: 'outcome.responseDref', + notes: [ + { + textKey: 'note.advancePayment', + link: { + url: DREF_GUIDELINES_ADVANCE_PAYMENT_URL, + labelKey: 'note.link.learnMore', + }, + }, + { + textKey: 'note.recurrentEvents', + link: { + url: DREF_GUIDELINES_RECURRENT_EVENTS_URL, + labelKey: 'note.link.learnMore', + }, + }, + ], + actions: [ + drefApplicationForm(getNewDrefRouteState(DREF_TYPE_RESPONSE, ONSET_SUDDEN)), + drefGuidelines(DREF_GUIDELINES_RESPONSE_URL), + ], + }, + o_assessmentDref: { + kind: 'outcome', + outcomeKey: 'outcome.assessmentDref', + notes: [{ textKey: 'note.conductAssessment' }], + // The design gives this leaf the form only, no guidelines link. + actions: [ + drefApplicationForm(getNewDrefRouteState(DREF_TYPE_ASSESSMENT, ONSET_SUDDEN)), + ], + }, + o_droughtDrefSlow: { + kind: 'outcome', + outcomeKey: 'outcome.droughtDref', + notes: [ + { textKey: 'note.insufficientEvidence' }, + { + textKey: 'note.recurrentEvents', + link: { + url: DREF_GUIDELINES_RECURRENT_EVENTS_URL, + labelKey: 'note.link.learnMore', + }, + }, + ], + actions: [ + drefApplicationForm( + getNewDrefRouteState(DREF_TYPE_RESPONSE, ONSET_SLOW, DISASTER_TYPE_DROUGHT), + ), + drefGuidelines(DREF_GUIDELINES_DROUGHT_URL), + ], + }, + o_responseDrefSlow: { + kind: 'outcome', + outcomeKey: 'outcome.responseDref', + notes: [{ + textKey: 'note.recurrentEvents', + link: { + url: DREF_GUIDELINES_RECURRENT_EVENTS_URL, + labelKey: 'note.link.learnMore', + }, + }], + actions: [ + drefApplicationForm(getNewDrefRouteState(DREF_TYPE_RESPONSE, ONSET_SLOW)), + drefGuidelines(DREF_GUIDELINES_RESPONSE_URL), + ], + }, + o_eapActivation: { + kind: 'outcome', + outcomeKey: 'outcome.eapActivation', + notes: [{ textKey: 'note.eapActivationByEmail' }], + actions: [drefGuidelines(DREF_GUIDELINES_EAP_ACTIVATION_URL)], + }, + o_exceptionalApproval: { + kind: 'outcome', + outcomeKey: 'outcome.exceptionalApproval', + notes: [ + { textKey: 'note.eapActivationByEmail' }, + { textKey: 'note.justifyExceptionalApproval' }, + ], + actions: [drefGuidelines(DREF_GUIDELINES_EAP_ACTIVATION_URL)], + }, + o_imminentDref: { + kind: 'outcome', + outcomeKey: 'outcome.imminentDref', + actions: [ + // The form forces sudden onset for imminent DREFs. + drefApplicationForm(getNewDrefRouteState(DREF_TYPE_IMMINENT, ONSET_SUDDEN)), + drefGuidelines(DREF_GUIDELINES_IMMINENT_URL), + ], + }, + o_droughtDrefAnticipatory: { + kind: 'outcome', + outcomeKey: 'outcome.droughtDref', + notes: [{ textKey: 'note.insufficientEvidence' }], + actions: [ + drefApplicationForm( + getNewDrefRouteState(DREF_TYPE_RESPONSE, ONSET_SLOW, DISASTER_TYPE_DROUGHT), + ), + drefGuidelines(DREF_GUIDELINES_DROUGHT_URL), + ], + }, + o_responseDrefReadiness: { + kind: 'outcome', + outcomeKey: 'outcome.responseDref', + actions: [ + drefApplicationForm(getNewDrefRouteState(DREF_TYPE_RESPONSE, ONSET_SLOW)), + drefGuidelines(DREF_GUIDELINES_READINESS_URL), + ], + }, + o_developEap: { + kind: 'outcome', + outcomeKey: 'outcome.developEap', + actions: [ + { + type: 'navigate', + route: 'newEapDevelopmentRegistration', + labelKey: 'cta.eapDevelopmentRegistration', + }, + drefGuidelines(DREF_GUIDELINES_EAP_DEVELOPMENT_URL), + ], + }, + }, +}; + +export default drefDecisionTree; diff --git a/app/src/components/domain/DrefDecisionTree/types.ts b/app/src/components/domain/DrefDecisionTree/types.ts new file mode 100644 index 0000000000..ae50853d1a --- /dev/null +++ b/app/src/components/domain/DrefDecisionTree/types.ts @@ -0,0 +1,75 @@ +// Stable identifier of a node within the decision graph. +export type NodeId = string; + +// Abstract content identifier. Resolved to a translated string in index.tsx. +// The graph never holds user-facing text, so copy can change without touching structure. +export type ContentKey = string; + +// What an outcome's call-to-action does. The graph declares INTENT only: where to +// go and what router state to seed there (e.g. initial values for the new-DREF +// form, built via getNewDrefRouteState). The target route owns any field-level +// derivation beyond that. +export type OutcomeAction = + | { + type: 'navigate'; + route: string; + urlParams?: Record; + state?: unknown; + // CTA label; falls back to the outcome's own label when omitted. + labelKey?: ContentKey; + } + | { + // Guidance published outside GO (the DREF Guidelines wiki, shared folders). + type: 'external'; + url: string; + labelKey: ContentKey; + }; + +export interface Option { + // Stable machine value. Branching and stored answers key off this, never off display copy. + value: string; + labelKey: ContentKey; + // Optional helper note shown after this option is chosen. + noteKey?: ContentKey; + // Next node. `null` marks a branch that is intentionally not defined yet (a known gap). + next: NodeId | null; +} + +export interface QuestionNode { + kind: 'question'; + questionKey: ContentKey; + options: Option[]; +} + +// Guidance shown with an outcome. `link` renders after the text, so copy and target +// stay separable (the tree owns the url, i18n.json owns the wording). +export interface OutcomeNote { + textKey: ContentKey; + link?: { + url: string; + labelKey: ContentKey; + }; +} + +export interface OutcomeNode { + kind: 'outcome'; + outcomeKey: ContentKey; + notes?: OutcomeNote[]; + // Empty for advisory-only outcomes, which carry their guidance in `notes`. + actions: OutcomeAction[]; +} + +export type TreeNode = QuestionNode | OutcomeNode; + +export interface DecisionTree { + root: NodeId; + nodes: Record; +} + +// A single answered step (which node was answered, and with which option value). +export interface Answer { + nodeId: NodeId; + value: string; +} + +export type AnswerPath = Answer[]; diff --git a/app/src/components/domain/DrefDecisionTree/validate.ts b/app/src/components/domain/DrefDecisionTree/validate.ts new file mode 100644 index 0000000000..40766d9e5f --- /dev/null +++ b/app/src/components/domain/DrefDecisionTree/validate.ts @@ -0,0 +1,79 @@ +import { isNotDefined } from '@togglecorp/fujs'; + +import { + type DecisionTree, + type NodeId, +} from './types'; + +interface TreeIssue { + level: 'error' | 'warning'; + nodeId?: NodeId; + message: string; +} + +// Structural invariants for the decision graph. Run in engine.test.ts so a malformed edit +// (a dangling `next`, a duplicate option value, an orphan node) fails CI instead of shipping. +// Intentional gaps (`next: null`) and unreachable nodes are reported as warnings, not errors. +export function validateTree(tree: DecisionTree): TreeIssue[] { + const issues: TreeIssue[] = []; + const ids = new Set(Object.keys(tree.nodes)); + + if (isNotDefined(tree.nodes[tree.root])) { + issues.push({ level: 'error', message: `root "${tree.root}" is not present in nodes` }); + } + + Object.entries(tree.nodes).forEach(([id, node]) => { + if (node.kind !== 'question') { + return; + } + if (node.options.length < 2) { + issues.push({ level: 'error', nodeId: id, message: 'question has fewer than 2 options' }); + } + const seen = new Set(); + node.options.forEach((opt) => { + if (seen.has(opt.value)) { + issues.push({ level: 'error', nodeId: id, message: `duplicate option value "${opt.value}"` }); + } + seen.add(opt.value); + + if (isNotDefined(opt.next)) { + issues.push({ level: 'warning', nodeId: id, message: `option "${opt.value}" has no destination yet (gap)` }); + } else if (!ids.has(opt.next)) { + issues.push({ level: 'error', nodeId: id, message: `option "${opt.value}" points to unknown node "${opt.next}"` }); + } + }); + }); + + // Reachability from the root. + const reachable = new Set(); + const stack: NodeId[] = [tree.root]; + while (stack.length > 0) { + const id = stack.pop(); + if (isNotDefined(id) || reachable.has(id)) { + continue; // eslint-disable-line no-continue + } + const node = tree.nodes[id]; + if (isNotDefined(node)) { + continue; // eslint-disable-line no-continue + } + reachable.add(id); + if (node.kind === 'question') { + node.options.forEach((opt) => { + if (!isNotDefined(opt.next)) { + stack.push(opt.next); + } + }); + } + } + ids.forEach((id) => { + if (!reachable.has(id)) { + issues.push({ level: 'warning', nodeId: id, message: 'node is unreachable from root' }); + } + }); + + return issues; +} + +export function getTreeErrors(tree: DecisionTree): TreeIssue[] { + return validateTree(tree).filter((issue) => issue.level === 'error'); +} diff --git a/app/src/components/domain/DrefDecisionTreeButton/i18n.json b/app/src/components/domain/DrefDecisionTreeButton/i18n.json new file mode 100644 index 0000000000..d2acc32266 --- /dev/null +++ b/app/src/components/domain/DrefDecisionTreeButton/i18n.json @@ -0,0 +1,6 @@ +{ + "namespace": "drefDecisionTreeButton", + "strings": { + "drefDecisionTreeButtonLabel": "DREF Decision Tree" + } +} diff --git a/app/src/components/domain/DrefDecisionTreeButton/index.tsx b/app/src/components/domain/DrefDecisionTreeButton/index.tsx new file mode 100644 index 0000000000..2c1844dd2c --- /dev/null +++ b/app/src/components/domain/DrefDecisionTreeButton/index.tsx @@ -0,0 +1,52 @@ +import { + useCallback, + useState, +} from 'react'; +import { + Button, + type ButtonLayoutProps, +} from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; + +import DrefDecisionTreeModal from '#components/domain/DrefDecisionTree'; + +import i18n from './i18n.json'; + +interface Props { + className?: string; + // Open the wizard on mount (e.g. when arriving from the Respond menu shortcut). + initiallyOpen?: boolean; + buttonStyleVariant?: ButtonLayoutProps['styleVariant']; +} + +function DrefDecisionTreeButton(props: Props) { + const { + className, + initiallyOpen = false, + buttonStyleVariant = 'filled', + } = props; + const strings = useTranslation(i18n); + + const [isShown, setIsShown] = useState(initiallyOpen); + const showModal = useCallback(() => setIsShown(true), []); + const hideModal = useCallback(() => setIsShown(false), []); + + return ( + <> + + {isShown && ( + + )} + + ); +} + +export default DrefDecisionTreeButton; diff --git a/app/src/components/domain/DrefDecisionTreeCallout/i18n.json b/app/src/components/domain/DrefDecisionTreeCallout/i18n.json new file mode 100644 index 0000000000..f2ea0d6f7d --- /dev/null +++ b/app/src/components/domain/DrefDecisionTreeCallout/i18n.json @@ -0,0 +1,7 @@ +{ + "namespace": "drefDecisionTreeCallout", + "strings": { + "decisionTreeCalloutHeading": "DREF Decision Tree", + "decisionTreeCalloutDescription": "If you are not sure which DREF application (response or anticipatory) best fits your situation, use the following decision tree, which will help you with your selection." + } +} diff --git a/app/src/components/domain/DrefDecisionTreeCallout/index.tsx b/app/src/components/domain/DrefDecisionTreeCallout/index.tsx new file mode 100644 index 0000000000..0e7ea6a463 --- /dev/null +++ b/app/src/components/domain/DrefDecisionTreeCallout/index.tsx @@ -0,0 +1,33 @@ +import { Container } from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; +import { _cs } from '@togglecorp/fujs'; + +import DrefDecisionTreeButton from '#components/domain/DrefDecisionTreeButton'; + +import i18n from './i18n.json'; +import styles from './styles.module.css'; + +interface Props { + className?: string; +} + +function DrefDecisionTreeCallout(props: Props) { + const { className } = props; + const strings = useTranslation(i18n); + + return ( + } + withPadding + withDarkBackground + spacing="lg" + headingLevel={4} + > + {strings.decisionTreeCalloutDescription} + + ); +} + +export default DrefDecisionTreeCallout; diff --git a/app/src/components/domain/DrefDecisionTreeCallout/styles.module.css b/app/src/components/domain/DrefDecisionTreeCallout/styles.module.css new file mode 100644 index 0000000000..a5e65757f2 --- /dev/null +++ b/app/src/components/domain/DrefDecisionTreeCallout/styles.module.css @@ -0,0 +1,4 @@ +.dref-decision-tree-callout { + align-self: center; + max-width: 40rem; +} diff --git a/app/src/components/domain/DrefDocumentLink/index.tsx b/app/src/components/domain/DrefDocumentLink/index.tsx new file mode 100644 index 0000000000..36bbdae38d --- /dev/null +++ b/app/src/components/domain/DrefDocumentLink/index.tsx @@ -0,0 +1,51 @@ +import { Button } from '@ifrc-go/ui'; +import { isDefined } from '@togglecorp/fujs'; + +import Link from '#components/Link'; + +interface Props { + className?: string; + // Only consumed by the disabled-button fallback. + name: string; + label: React.ReactNode; + url: string | undefined; +} + +// A missing url degrades to a disabled button rather than an inert anchor. +function DrefDocumentLink(props: Props) { + const { + className, + name, + label, + url, + } = props; + + if (isDefined(url)) { + return ( + + {label} + + ); + } + + return ( + + ); +} + +export default DrefDocumentLink; diff --git a/app/src/components/domain/DrefKeyResources/i18n.json b/app/src/components/domain/DrefKeyResources/i18n.json new file mode 100644 index 0000000000..dcf8e30663 --- /dev/null +++ b/app/src/components/domain/DrefKeyResources/i18n.json @@ -0,0 +1,19 @@ +{ + "namespace": "drefKeyResources", + "strings": { + "keyResourcesHeading": "Key DREF resources", + "openDocument": "Open document", + "drefProceduresName": "DREF Procedures", + "drefProceduresDescription": "Comprehensive operational procedures for all DREF modalities including application, approval, and reporting requirements.", + "drefGuidelinesName": "DREF Guidelines", + "drefGuidelinesDescription": "Detailed technical guidance covering eligibility criteria, activity design, budget planning, and implementation standards.", + "anticipationHubName": "Anticipation Hub Website", + "anticipationHubDescription": "A wealth of resources available on anticipatory action for a range of stakeholders.", + "aaManualName": "AA Manual", + "aaManualDescription": "A detailed overview on how to develop an Early Action Protocol.", + "erfName": "Emergency Response Framework (ERF)", + "erfDescription": "Official Framework which determines the mechanisms, roles and responsibilities, as well as operational pathways for IFRC supported operations.", + "rbmName": "Results-Based Management (RBM)", + "rbmDescription": "Guidance on results-based planning, monitoring, reporting, and operational learning for DREF operations, helping teams deliver measurable, accountable, and effective humanitarian responses." + } +} diff --git a/app/src/components/domain/DrefKeyResources/index.tsx b/app/src/components/domain/DrefKeyResources/index.tsx new file mode 100644 index 0000000000..86692be69e --- /dev/null +++ b/app/src/components/domain/DrefKeyResources/index.tsx @@ -0,0 +1,123 @@ +import { + Container, + ListView, +} from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; + +import DrefDocumentLink from '#components/domain/DrefDocumentLink'; +import { + ANTICIPATION_HUB_URL, + DREF_AA_MANUAL_URL, + DREF_ERF_URL, + DREF_GUIDELINES_URL, + DREF_PROCEDURES_URL, + DREF_RBM_URL, +} from '#utils/domain/dref'; + +import i18n from './i18n.json'; + +interface Resource { + key: string; + name: string; + description: string; + url: string | undefined; +} + +interface Props { + className?: string; + // Both pillars open with the same two DREF documents and then diverge: + // anticipatory adds the anticipatory-action references, response adds the + // response framework and planning guidance. + variant: 'anticipatory' | 'response'; +} + +function DrefKeyResources(props: Props) { + const { + className, + variant, + } = props; + const strings = useTranslation(i18n); + + const sharedResources: Resource[] = [ + { + key: 'procedures', + name: strings.drefProceduresName, + description: strings.drefProceduresDescription, + url: DREF_PROCEDURES_URL, + }, + { + key: 'guidelines', + name: strings.drefGuidelinesName, + description: strings.drefGuidelinesDescription, + url: DREF_GUIDELINES_URL, + }, + ]; + + const variantResources: Resource[] = variant === 'anticipatory' + ? [ + { + key: 'anticipationHub', + name: strings.anticipationHubName, + description: strings.anticipationHubDescription, + url: ANTICIPATION_HUB_URL, + }, + { + key: 'aaManual', + name: strings.aaManualName, + description: strings.aaManualDescription, + url: DREF_AA_MANUAL_URL, + }, + ] + : [ + { + key: 'erf', + name: strings.erfName, + description: strings.erfDescription, + url: DREF_ERF_URL, + }, + { + key: 'rbm', + name: strings.rbmName, + description: strings.rbmDescription, + url: DREF_RBM_URL, + }, + ]; + + const resources = [...sharedResources, ...variantResources]; + + return ( + + + {resources.map((resource) => ( + + )} + > + {resource.description} + + ))} + + + ); +} + +export default DrefKeyResources; diff --git a/app/src/components/domain/Faq/index.tsx b/app/src/components/domain/Faq/index.tsx new file mode 100644 index 0000000000..662b6a530b --- /dev/null +++ b/app/src/components/domain/Faq/index.tsx @@ -0,0 +1,45 @@ +import { type ReactNode } from 'react'; +import { + ExpandableContainer, + ListView, +} from '@ifrc-go/ui'; + +export interface FaqItem { + // Stable key — independent of the (translatable) question text. + name: string; + question: ReactNode; + answer: ReactNode; +} + +interface Props { + className?: string; + items: FaqItem[]; +} + +function Faq(props: Props) { + const { className, items } = props; + + return ( + + {items.map((item) => ( + + {item.answer} + + ))} + + ); +} + +export default Faq; diff --git a/app/src/utils/constants.ts b/app/src/utils/constants.ts index 83cc00bfd5..6c45eb0392 100644 --- a/app/src/utils/constants.ts +++ b/app/src/utils/constants.ts @@ -101,6 +101,7 @@ export const DREF_TYPE_LOAN = 3 satisfies TypeOfDrefEnum; type TypeOfOnsetEnum = components<'read'>['schemas']['DrefDrefOnsetTypeEnumKey']; export const ONSET_SLOW = 1 satisfies TypeOfOnsetEnum; +export const ONSET_SUDDEN = 2 satisfies TypeOfOnsetEnum; // Subscriptions type SubscriptionRecordTypeEnum = components<'read'>['schemas']['RtypeEnum']; @@ -141,6 +142,7 @@ export type CategoryType = components<'read'>['schemas']['ApiActionCategoryEnumK // FIXME: we need to identify a typesafe way to get these values export const DISASTER_TYPE_EPIDEMIC = 1; export const DISASTER_TYPE_OTHER = 13; +export const DISASTER_TYPE_DROUGHT = 20; type Visibility = components<'read'>['schemas']['ApiVisibilityChoicesEnumKey']; export const VISIBILITY_RCRC_MOVEMENT = 1 satisfies Visibility; diff --git a/app/src/utils/domain/dref.ts b/app/src/utils/domain/dref.ts index 074c36e774..2962848772 100644 --- a/app/src/utils/domain/dref.ts +++ b/app/src/utils/domain/dref.ts @@ -1,4 +1,61 @@ import { type components } from '#generated/types'; +import { type TypeOfDrefEnum } from '#utils/constants'; + +type TypeOfOnsetEnum = components<'read'>['schemas']['DrefDrefOnsetTypeEnumKey']; + +const GO_WIKI_DREF_GUIDELINES = 'https://go-wiki.ifrc.org/en/DREF/DREF_Guidelines_2026'; + +export const DREF_GUIDELINES_DROUGHT_URL = `${GO_WIKI_DREF_GUIDELINES}#dref-p126-response-dref-for-drought-specific-slow-onset-crises`; +export const DREF_GUIDELINES_READINESS_URL = `${GO_WIKI_DREF_GUIDELINES}#dref-p128-dref-support-for-readiness-actions`; +export const DREF_GUIDELINES_LOAN_URL = `${GO_WIKI_DREF_GUIDELINES}#dref-p130-dref-loan-for-red-category-emergencies`; +export const DREF_AA_MANUAL_URL = 'https://manual.anticipatory-action.org/en/'; + +// Per-outcome guidance targets used by the DREF decision tree. +export const DREF_GUIDELINES_RESPONSE_URL = `${GO_WIKI_DREF_GUIDELINES}#dref-p121-4-4-allocation-parameters-under-response-dref`; +export const DREF_GUIDELINES_IMMINENT_URL = `${GO_WIKI_DREF_GUIDELINES}#dref-p73-3-5-imminent-dref`; +export const DREF_GUIDELINES_EAP_ACTIVATION_URL = `${GO_WIKI_DREF_GUIDELINES}#dref-p59-s-eap-activation`; +export const DREF_GUIDELINES_EAP_DEVELOPMENT_URL = `${GO_WIKI_DREF_GUIDELINES}#dref-p48-3-4-2-s-eap-development-and-submission-process`; +export const DREF_GUIDELINES_ADVANCE_PAYMENT_URL = `${GO_WIKI_DREF_GUIDELINES}#dref-p161-review-approval-and-disbursement-with-emergency-advance-payment`; +export const DREF_GUIDELINES_RECURRENT_EVENTS_URL = `${GO_WIKI_DREF_GUIDELINES}#dref-p133-recurrent-events-and-accessing-dref-funding`; +// Emergency Appeals live outside GO; the decision tree points at the shared document folder. +export const EMERGENCY_APPEAL_RESOURCES_URL = 'https://ifrcorg.sharepoint.com/:f:/s/IFRCSharing/IgDOBQt_IudIR54zFy6L0L2tATWUZbUMzw9Migz9_WtoPA0?e=0ccrAd'; + +export const DREF_ANTICIPATORY_GUIDANCE_URL = `${GO_WIKI_DREF_GUIDELINES}#h-3-anticipatory-pillar`; +export const DREF_RESPONSE_GUIDANCE_URL: string | undefined = `${GO_WIKI_DREF_GUIDELINES}#h-4-response-pillar`; + +// Key DREF resources. The SharePoint links are the ones supplied by the DREF team with +// their mail-session parameters (ct/or/ga/LOF/cid/ovuser/xsdata) stripped, leaving only +// the document identity. They still require an IFRC login. +export const DREF_PROCEDURES_URL: string | undefined = 'https://ifrcorg.sharepoint.com/sites/IFRCSharing/Shared%20Documents/Forms/AllItems.aspx?id=%2Fsites%2FIFRCSharing%2FShared%20Documents%2FDREF%2FNew%20DREF%20Procedures%2FDREF%20Procedures%5Fsigned%2Dversion%2Epdf&parent=%2Fsites%2FIFRCSharing%2FShared%20Documents%2FDREF%2FNew%20DREF%20Procedures'; +export const DREF_GUIDELINES_URL: string | undefined = 'https://ifrcorg.sharepoint.com/sites/IFRCSharing/Shared%20Documents/Forms/AllItems.aspx?id=%2Fsites%2FIFRCSharing%2FShared%20Documents%2FDREF%2FDREF%20Procedures%20and%20Guidelines%2FDREF%20Guidelines%202026%2Epdf&parent=%2Fsites%2FIFRCSharing%2FShared%20Documents%2FDREF%2FDREF%20Procedures%20and%20Guidelines'; +export const DREF_RBM_URL: string | undefined = 'https://ifrcorg.sharepoint.com/:f:/s/IFRCSharing/IgBYYWWQVGHiS5rnwYXIX1ObAYFM5-IBl4BLsh_vSKwQwAE'; +export const ANTICIPATION_HUB_URL: string | undefined = 'https://www.anticipation-hub.org/'; +export const DREF_ERF_URL: string | undefined = 'https://www.ifrc.org/sites/default/files/2026-04/IFRC%20Emergency%20Response%20Framework.pdf'; + +// TODO: fill in once the form is published; until then DrefDocumentLink renders a +// disabled button. +export const DREF_ADVANCE_PAYMENT_FORM_URL: string | undefined = undefined; + +// Router state consumed by DrefApplicationForm (via useLocation().state) to seed a +// NEW application. Entry points (pillar buttons, decision tree) declare intent only; +// the form derives the type-dependent fields (onset, proposed actions) on load. +interface NewDrefRouteState { + type_of_dref: TypeOfDrefEnum; + type_of_onset?: TypeOfOnsetEnum; + disaster_type?: number; +} + +export function getNewDrefRouteState( + typeOfDref: TypeOfDrefEnum, + typeOfOnset?: TypeOfOnsetEnum, + disasterType?: number, +): NewDrefRouteState { + return { + type_of_dref: typeOfDref, + type_of_onset: typeOfOnset, + disaster_type: disasterType, + }; +} type PlannedIntervention = components<'read'>['schemas']['PlannedIntervention']; type PlannedInterventionTitle = NonNullable; diff --git a/app/src/views/Dref/i18n.json b/app/src/views/Dref/i18n.json new file mode 100644 index 0000000000..a50df17f46 --- /dev/null +++ b/app/src/views/Dref/i18n.json @@ -0,0 +1,11 @@ +{ + "namespace": "dref", + "strings": { + "home": "Home", + "respond": "Respond", + "drefHeading": "Disaster Response Emergency Fund (DREF)", + "drefDescription": "The Disaster Response Emergency Fund (DREF) provides rapid and reliable funding to National Societies to prepare for and respond to crises. This page is the main hub for understanding how DREF works, choosing the right modality, and exploring active operations.", + "drefAnticipatoryPillarTab": "Anticipatory Pillar", + "drefResponsePillarTab": "Response Pillar" + } +} diff --git a/app/src/views/Dref/index.tsx b/app/src/views/Dref/index.tsx new file mode 100644 index 0000000000..29358dc5c3 --- /dev/null +++ b/app/src/views/Dref/index.tsx @@ -0,0 +1,101 @@ +import { + useEffect, + useState, +} from 'react'; +import { + Outlet, + useLocation, + useNavigate, +} from 'react-router-dom'; +import { + Breadcrumbs, + ListView, + NavigationTabList, +} from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; +import { isDefined } from '@togglecorp/fujs'; + +import DrefDecisionTreeButton from '#components/domain/DrefDecisionTreeButton'; +import Link from '#components/Link'; +import NavigationTab from '#components/NavigationTab'; +import Page from '#components/Page'; + +import i18n from './i18n.json'; + +interface DrefLocationState { + // Set by the Respond > DREF Decision Tree menu item to open the wizard on arrival. + openDecisionTree?: boolean; +} + +// eslint-disable-next-line import/prefer-default-export +export function Component() { + const strings = useTranslation(i18n); + const location = useLocation(); + const navigate = useNavigate(); + + const [treeRequestKey, setTreeRequestKey] = useState(); + + useEffect(() => { + if ((location.state as DrefLocationState | null)?.openDecisionTree) { + // Consume the request then clear the router state so + // Back/reload does not reopen the decision tree. + // eslint-disable-next-line react-hooks/set-state-in-effect + setTreeRequestKey(location.key); + navigate( + { + pathname: location.pathname, + search: location.search, + hash: location.hash, + }, + { + replace: true, + state: null, + preventScrollReset: true, + }, + ); + } + }, [location, navigate]); + + return ( + + + {strings.home} + + {strings.respond} + {/* Not a self-link: the dref layout route forwards to the + response pillar, which would switch tabs. */} + {strings.drefHeading} + + )} + description={( + + {strings.drefDescription} + + + )} + > + + + {strings.drefAnticipatoryPillarTab} + + + {strings.drefResponsePillarTab} + + + + + ); +} + +Component.displayName = 'Dref'; diff --git a/app/src/views/DrefAnticipatoryPillar/EapMap/i18n.json b/app/src/views/DrefAnticipatoryPillar/EapMap/i18n.json new file mode 100644 index 0000000000..47922e3449 --- /dev/null +++ b/app/src/views/DrefAnticipatoryPillar/EapMap/i18n.json @@ -0,0 +1,8 @@ +{ + "namespace": "eapMap", + "strings": { + "eapMapTitle": "Approved EAPs", + "eapMapType": "EAP type", + "eapMapLoginRequired": "Log in to view the map of approved EAPs." + } +} diff --git a/app/src/views/DrefAnticipatoryPillar/EapMap/index.tsx b/app/src/views/DrefAnticipatoryPillar/EapMap/index.tsx new file mode 100644 index 0000000000..efb26e27e8 --- /dev/null +++ b/app/src/views/DrefAnticipatoryPillar/EapMap/index.tsx @@ -0,0 +1,108 @@ +import { + useCallback, + useMemo, +} from 'react'; +import { + Container, + ListView, + TextOutput, +} from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; +import { + isDefined, + listToGroupList, +} from '@togglecorp/fujs'; + +import CountryPointsMap, { type CountryPoint } from '#components/domain/CountryPointsMap'; +import useAuth from '#hooks/domain/useAuth'; +import { + COLOR_BLUE, + EAP_STATUS_APPROVED, +} from '#utils/constants'; +import { useRequest } from '#utils/restRequest'; + +import i18n from './i18n.json'; + +const MAP_LIMIT = 1000; + +// Only approved EAPs are mapped: there is no "active/activated" EAP status, so per the +// design annotation we show approved only (and render no legend). +function EapMap() { + const strings = useTranslation(i18n); + // Public page, private endpoint: without the skip an empty map reads as + // "no approved EAPs". + const { isAuthenticated } = useAuth(); + + const { + pending, + error, + response, + } = useRequest({ + skip: !isAuthenticated, + url: '/api/v2/eap-registration/', + preserveResponse: true, + query: { + status: EAP_STATUS_APPROVED, + limit: MAP_LIMIT, + }, + }); + + const eapsByIso3 = useMemo( + () => listToGroupList( + (response?.results ?? []).filter((eap) => isDefined(eap.country_details?.iso3)), + (eap) => eap.country_details?.iso3 as string, + ), + [response], + ); + + const points = useMemo( + () => Object.keys(eapsByIso3).map((iso3) => ({ iso3, color: COLOR_BLUE })), + [eapsByIso3], + ); + + const renderPopup = useCallback( + (iso3: string) => { + const eaps = eapsByIso3[iso3] ?? []; + return ( + + {eaps.map((eap) => ( + + + + ))} + + ); + }, + [eapsByIso3, strings.eapMapType], + ); + + return ( + + + + ); +} + +export default EapMap; diff --git a/app/src/views/DrefAnticipatoryPillar/EapTable/i18n.json b/app/src/views/DrefAnticipatoryPillar/EapTable/i18n.json new file mode 100644 index 0000000000..a64dc0faae --- /dev/null +++ b/app/src/views/DrefAnticipatoryPillar/EapTable/i18n.json @@ -0,0 +1,13 @@ +{ + "namespace": "eapTable", + "strings": { + "eapTableHeading": "Recent EAPs", + "eapTableDate": "Date of Approval / Activation", + "eapTableName": "EAP Title", + "eapTableStatus": "EAP Status", + "eapTableCountry": "Country", + "eapTableDisasterType": "Disaster Type", + "eapTableRequirements": "Requirements (CHF)", + "eapTableLoginRequired": "Log in to view recent EAPs." + } +} diff --git a/app/src/views/DrefAnticipatoryPillar/EapTable/index.tsx b/app/src/views/DrefAnticipatoryPillar/EapTable/index.tsx new file mode 100644 index 0000000000..a5cedfcbc4 --- /dev/null +++ b/app/src/views/DrefAnticipatoryPillar/EapTable/index.tsx @@ -0,0 +1,186 @@ +import { useMemo } from 'react'; +import { + Container, + Pager, + Table, +} from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; +import { + createDateColumn, + createStringColumn, + numericIdSelector, +} from '@ifrc-go/ui/utils'; +import { + isDefined, + isNotDefined, + listToMap, +} from '@togglecorp/fujs'; + +import useAuth from '#hooks/domain/useAuth'; +import useGlobalEnums from '#hooks/domain/useGlobalEnums'; +import useFilterState from '#hooks/useFilterState'; +import { EAP_TYPE_FULL } from '#utils/constants'; +import { + createBudgetColumn, + createLinkColumn, +} from '#utils/domain/tableHelpers'; +import { + type GoApiResponse, + type GoApiUrlQuery, + useRequest, +} from '#utils/restRequest'; + +import i18n from './i18n.json'; + +type EapResponse = GoApiResponse<'/api/v2/eap-registration/'>; +type EapQueryParams = GoApiUrlQuery<'/api/v2/eap-registration/'>; +type EapListItem = NonNullable[number]; +type Key = EapListItem['id']; + +const PAGE_SIZE = 10; + +interface Props { + className?: string; +} + +function EapTable(props: Props) { + const { className } = props; + const strings = useTranslation(i18n); + const { eap_eap_status: eapStatusOptions } = useGlobalEnums(); + // Public page, private endpoint: without the skip this reads as an empty + // table rather than a login prompt. + const { isAuthenticated } = useAuth(); + + const { + page, + setPage, + limit, + offset, + filtered, + } = useFilterState<{ status?: number }>({ + filter: {}, + pageSize: PAGE_SIZE, + }); + + const query = useMemo( + () => ({ + limit, + offset, + }), + [limit, offset], + ); + + const { + pending, + response, + } = useRequest({ + skip: !isAuthenticated, + url: '/api/v2/eap-registration/', + preserveResponse: true, + query, + }); + + const eapStatusMap = useMemo( + () => listToMap( + eapStatusOptions ?? [], + (status) => status.key, + (status) => status.value, + ), + [eapStatusOptions], + ); + + const columns = useMemo( + () => ([ + createDateColumn( + 'approved_at', + strings.eapTableDate, + (item) => item.approved_at, + ), + // EAP name links to the generated EAP Summary PDF. + // TODO: open in a new window once the export route supports it. + createLinkColumn( + 'name', + strings.eapTableName, + (item) => [item.country_details?.name, item.disaster_type_details?.name] + .filter(isDefined) + .join(' – '), + (item) => ({ + to: 'eapSummaryExport', + urlParams: { eapId: item.id }, + }), + ), + createStringColumn( + 'status', + strings.eapTableStatus, + (item) => (isDefined(item.status) ? eapStatusMap?.[item.status] : undefined), + ), + createStringColumn( + 'country', + strings.eapTableCountry, + (item) => item.country_details?.name, + ), + createStringColumn( + 'disaster_type', + strings.eapTableDisasterType, + (item) => item.disaster_type_details?.name, + ), + createBudgetColumn( + 'total_budget', + strings.eapTableRequirements, + (item) => { + const fullBudget = item.full_eap_details?.find( + (detail) => detail.id === item.latest_full_eap, + )?.total_budget; + const simplifiedBudget = item.simplified_eap_details?.find( + (detail) => detail.id === item.latest_simplified_eap, + )?.total_budget; + + if (isNotDefined(item.eap_type)) { + return fullBudget ?? simplifiedBudget; + } + + return item.eap_type === EAP_TYPE_FULL + ? fullBudget + : simplifiedBudget; + }, + ), + ]), + [ + eapStatusMap, + strings.eapTableDate, + strings.eapTableName, + strings.eapTableStatus, + strings.eapTableCountry, + strings.eapTableDisasterType, + strings.eapTableRequirements, + ], + ); + + return ( + + ) : undefined} + > + + + ); +} + +export default EapTable; diff --git a/app/src/views/DrefAnticipatoryPillar/ImminentDrefMap/i18n.json b/app/src/views/DrefAnticipatoryPillar/ImminentDrefMap/i18n.json new file mode 100644 index 0000000000..4ae22d909b --- /dev/null +++ b/app/src/views/DrefAnticipatoryPillar/ImminentDrefMap/i18n.json @@ -0,0 +1,10 @@ +{ + "namespace": "imminentDrefMap", + "strings": { + "imminentMapTitle": "Map of Imminent DREF operations", + "imminentMapDisasterTypePlaceholder": "All Hazards", + "imminentMapLegend": "Imminent DREF", + "imminentMapLoginRequired": "Log in to view the map of imminent DREF operations.", + "imminentMapStatus": "Status" + } +} diff --git a/app/src/views/DrefAnticipatoryPillar/ImminentDrefMap/index.tsx b/app/src/views/DrefAnticipatoryPillar/ImminentDrefMap/index.tsx new file mode 100644 index 0000000000..986aee0743 --- /dev/null +++ b/app/src/views/DrefAnticipatoryPillar/ImminentDrefMap/index.tsx @@ -0,0 +1,137 @@ +import { + useCallback, + useMemo, +} from 'react'; +import { + Container, + ListView, + TextOutput, +} from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; +import { + isDefined, + listToGroupList, +} from '@togglecorp/fujs'; + +import CountryPointsMap, { + type CountryPoint, + type MapLegendOption, +} from '#components/domain/CountryPointsMap'; +import DisasterTypeSelectInput from '#components/domain/DisasterTypeSelectInput'; +import useAuth from '#hooks/domain/useAuth'; +import useFilterState from '#hooks/useFilterState'; +import { + COLOR_BLUE, + DREF_TYPE_IMMINENT, +} from '#utils/constants'; +import { useRequest } from '#utils/restRequest'; + +import i18n from './i18n.json'; + +const MAP_LIMIT = 1000; + +function ImminentDrefMap() { + const strings = useTranslation(i18n); + // Public page, private endpoint: without the skip an empty map reads as + // "no imminent DREFs". + const { isAuthenticated } = useAuth(); + + const { + filter, + rawFilter, + setFilterField, + } = useFilterState<{ + disasterType?: number; + }>({ + filter: {}, + }); + + const { + pending, + error, + response, + } = useRequest({ + skip: !isAuthenticated, + url: '/api/v2/active-dref/', + preserveResponse: true, + query: { + type_of_dref: [DREF_TYPE_IMMINENT], + disaster_type: filter.disasterType, + limit: MAP_LIMIT, + }, + }); + + const drefsByIso3 = useMemo( + () => listToGroupList( + (response?.results ?? []).filter((dref) => isDefined(dref.country_details?.iso3)), + (dref) => dref.country_details?.iso3 as string, + ), + [response], + ); + + const points = useMemo( + () => Object.keys(drefsByIso3).map((iso3) => ({ iso3, color: COLOR_BLUE })), + [drefsByIso3], + ); + + const legendOptions = useMemo( + () => [{ value: 'imminent', label: strings.imminentMapLegend, color: COLOR_BLUE }], + [strings.imminentMapLegend], + ); + + const renderPopup = useCallback( + (iso3: string) => { + const drefs = drefsByIso3[iso3] ?? []; + return ( + + {drefs.map((dref) => ( + + + + ))} + + ); + }, + [drefsByIso3, strings.imminentMapStatus], + ); + + return ( + + ) : undefined} + > + + + ); +} + +export default ImminentDrefMap; diff --git a/app/src/views/DrefAnticipatoryPillar/ImminentDrefTable/i18n.json b/app/src/views/DrefAnticipatoryPillar/ImminentDrefTable/i18n.json new file mode 100644 index 0000000000..d76ae757cb --- /dev/null +++ b/app/src/views/DrefAnticipatoryPillar/ImminentDrefTable/i18n.json @@ -0,0 +1,15 @@ +{ + "namespace": "imminentDrefTable", + "strings": { + "imminentTableHeading": "Imminent DREF operations", + "imminentStartDate": "Start Date", + "imminentCode": "Appeal Code", + "imminentOperation": "Operation", + "imminentDisasterType": "Disaster Type", + "imminentCountry": "Country", + "imminentFilterSearchPlaceholder": "Search", + "imminentFilterAllYears": "All Years", + "imminentClearFilters": "Clear Filters", + "imminentLoginRequired": "Log in to view imminent DREF operations." + } +} diff --git a/app/src/views/DrefAnticipatoryPillar/ImminentDrefTable/index.tsx b/app/src/views/DrefAnticipatoryPillar/ImminentDrefTable/index.tsx new file mode 100644 index 0000000000..5bb2afb9f3 --- /dev/null +++ b/app/src/views/DrefAnticipatoryPillar/ImminentDrefTable/index.tsx @@ -0,0 +1,225 @@ +import { useMemo } from 'react'; +import { SearchLineIcon } from '@ifrc-go/icons'; +import { + Button, + Container, + Pager, + SelectInput, + Table, + TextInput, +} from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; +import { + createDateColumn, + numericIdSelector, + numericKeySelector, + stringValueSelector, +} from '@ifrc-go/ui/utils'; +import { + isDefined, + listToMap, +} from '@togglecorp/fujs'; + +import useAuth from '#hooks/domain/useAuth'; +import useDisasterTypes from '#hooks/domain/useDisasterType'; +import useFilterState from '#hooks/useFilterState'; +import { DREF_TYPE_IMMINENT } from '#utils/constants'; +import { + createAppealCodeColumn, + createCountryColumn, + createDisasterTypeColumn, + createTitleColumn, +} from '#utils/domain/tableHelpers'; +import { + type GoApiResponse, + type GoApiUrlQuery, + useRequest, +} from '#utils/restRequest'; + +import i18n from './i18n.json'; + +type ActiveDrefQueryParams = GoApiUrlQuery<'/api/v2/active-dref/'>; +type ActiveDrefResponse = GoApiResponse<'/api/v2/active-dref/'>; +type ActiveDrefItem = NonNullable[number]; +type Key = ActiveDrefItem['id']; + +const PAGE_SIZE = 10; +const FIRST_YEAR = 2018; +const now = new Date(); +const yearOptions = Array.from( + { length: now.getFullYear() - FIRST_YEAR + 1 }, + (_, i) => ({ + key: now.getFullYear() - i, + value: String(now.getFullYear() - i), + }), +); + +function ImminentDrefTable() { + const strings = useTranslation(i18n); + const disasterTypes = useDisasterTypes(); + // Public page, private endpoint: without the skip this reads as an empty + // table rather than a login prompt. + const { isAuthenticated } = useAuth(); + + const { + page, + setPage, + limit, + offset, + rawFilter, + filter, + setFilterField, + resetFilter, + rawFiltered, + filtered, + } = useFilterState<{ + search?: string, + year?: number, + }>({ + filter: {}, + pageSize: PAGE_SIZE, + }); + + const query = useMemo( + () => ({ + limit, + offset, + type_of_dref: [DREF_TYPE_IMMINENT], + search: filter.search, + // The backend filters accept dates only (%Y-%m-%d); Jan 1 of the + // next year as the upper bound keeps Dec 31 records included. + created_at__gte: isDefined(filter.year) + ? `${filter.year}-01-01` + : undefined, + created_at__lte: isDefined(filter.year) + ? `${filter.year + 1}-01-01` + : undefined, + }), + [limit, offset, filter], + ); + + const { + pending, + response, + } = useRequest({ + skip: !isAuthenticated, + url: '/api/v2/active-dref/', + preserveResponse: true, + query, + }); + + const disasterTypeMap = useMemo( + () => listToMap( + disasterTypes ?? [], + (disasterType) => disasterType.id, + (disasterType) => disasterType.name, + ), + [disasterTypes], + ); + + const columns = useMemo( + () => ([ + createDateColumn( + 'created_at', + strings.imminentStartDate, + (item) => item.created_at, + ), + createAppealCodeColumn( + 'appeal_code', + strings.imminentCode, + (item) => item.appeal_code, + ), + // NOTE: /api/v2/active-dref/ does not expose the linked emergency, so + // the title cannot be a link yet (see MiniDrefSerializer in go-api). + createTitleColumn( + 'operation', + strings.imminentOperation, + (item) => item.title, + ), + createDisasterTypeColumn( + 'disaster_type', + strings.imminentDisasterType, + (item) => (isDefined(item.disaster_type) + ? disasterTypeMap?.[item.disaster_type] + : undefined), + ), + createCountryColumn( + 'country', + strings.imminentCountry, + (item) => item.country_details?.name, + (item) => (isDefined(item.country) + ? { + to: 'countriesLayout', + urlParams: { countryId: item.country }, + } + : { + to: undefined, + withUnderline: false, + }), + ), + ]), + [ + disasterTypeMap, + strings.imminentStartDate, + strings.imminentCode, + strings.imminentOperation, + strings.imminentDisasterType, + strings.imminentCountry, + ], + ); + + return ( + + } + /> + + {rawFiltered && ( + + )} + + ) : undefined} + footerActions={isAuthenticated ? ( + + ) : undefined} + > +
+ + ); +} + +export default ImminentDrefTable; diff --git a/app/src/views/DrefAnticipatoryPillar/i18n.json b/app/src/views/DrefAnticipatoryPillar/i18n.json new file mode 100644 index 0000000000..05fad923c7 --- /dev/null +++ b/app/src/views/DrefAnticipatoryPillar/i18n.json @@ -0,0 +1,128 @@ +{ + "namespace": "drefAnticipatoryPillar", + "strings": { + "anticipatoryIntroOne": "The Anticipatory Pillar of the Disaster Response Emergency Fund (DREF) enables National Red Cross and Red Crescent Societies to act before a disaster strikes. By providing preapproving plans and budgets during peacetime, National Societies can implement anticipatory or early action activities, based on pre-agreed triggers, that aim to reduce or mitigate the humanitarian impacts of predictable hazards on at-risk communities.", + "anticipatoryIntroTwo": "Traditionally, humanitarian assistance was triggered only after a disaster had already caused damage. This often resulted in delayed response, increased human suffering, and greater financial costs. In contrast, anticipatory action allows the humanitarian system to shift from a reactive to a proactive model, responding to predicted disasters rather than waiting for the consequences to unfold.", + "fullAnticipatoryGuidanceLink": "Full Anticipatory Pillar Guidance", + "imminentCardHeading": "Imminent DREF", + "imminentCardText": "Use this for sudden-onset disasters only, when the event has not materialized yet and the National Society has no Early Action Protocol in place to act ahead. The template is short and approval is quick, so your decision-making has to be quick too.", + "imminentCardButton": "Start Imminent DREF", + "eapCardHeading": "Early Action Protocols (EAP)", + "eapCardText": "Use this when you want to have a plan that guides the implementation of early action activities which will reduce and mitigate the humanitarian impacts of a forecasted hazard. These plans are developed and approved in peacetime, and bring together a pre-agreed plan with preapproved trigger and guaranteed funding, which gives National Society the confidence to work in advance of both weather and non-weather-related events. Two types exist: the Early Action Protocol (EAP) and the Simplified Early Action Protocol (sEAP).", + "eapCardButton": "Register EAP", + "subTabImminent": "Imminent DREF", + "subTabEap": "Early Action Protocols", + "imminentTabDescription": "Imminent DREF is meant for sudden-onset disasters only and can be used in the context where a disaster has not started to unfold, but has a high likelihood of happening, or a disaster which has started to unfold and has not reached its full impact yet. An imminent DREF has a short and simple request template and a quick approval process, but requires strong decision-making processes to ensure timely implementation.", + "faqImminentDrefQuestion": "What is an Imminent DREF?", + "faqImminentDrefIntro": "Imminent DREF is specifically designed for situations where a National Society does not have a pre-approved Early Action Protocol (EAP) or Simplified EAP (sEAP) but has the opportunity to implement early action in advance of a hazard that is clearly on the horizon.", + "faqImminentDrefScope": "This modality is intended exclusively for sudden-onset disasters where the risk of disaster is clear and imminent, but where the window to act is extremely limited. It enables National Societies to implement critical early action and early response actions when:", + "faqImminentDrefBulletNotYet": "A disaster has not yet occurred, but is highly likely to happen in the near future based on reliable forecasts or early warnings; or", + "faqImminentDrefBulletUnfolding": "A disaster has begun to unfold, but has not yet reached its peak impact, and there remains a short lead time to mitigate the worst effects.", + "faqImminentDrefOutro": "Imminent DREF should not be a replacement for longer-term anticipatory planning. Rather, it serves as a critical stopgap in situations where the National Society has had no time or resources to formalize a pre-approved protocol. It is also an entry point for a National Society who is still in the process of developing an s/EAP or has an EAP in place which covers a higher scale of disaster.", + "faqImminentCharacteristicsQuestion": "Imminent DREF Characteristics", + "faqImminentCharTimeframe": "Operating timeframe: 45 days, with no possibility of extension.", + "faqImminentCharTrigger": "Trigger mechanism: no pre-agreed trigger; decision is driven by high-confidence forecasts or expert judgement of an imminent event (e.g. a government or national/regional weather agency issues a severe weather alert for a specific area with high certainty).", + "faqImminentCharThresholds": "Total allocation thresholds capped at:", + "faqImminentCharThresholdsNoRrp": "CHF 80,000, if Rapid Response Personnel (RRP) is not requested. In this case, the Imminent DREF does not include an allocation for IFRC direct costs, it is solely for the National Society.", + "faqImminentCharThresholdsWithRrp": "CHF 90,800, if Rapid Response Personnel (RRP) was requested. In this case, the Imminent DREF includes IFRC direct costs for deployment of Rapid Response Personnel.", + "faqImminentCharComponents": "Components: no readiness and prepositioning activities as the focus is entirely on immediate early action.", + "faqImminentCharEarlyAction": "Early action activities: activities which will prevent or mitigate the expected impact of the disaster. Early action activities are time-sensitive and must be implemented rapidly in advance of the hazard. National Societies may include items procurement for immediate use, or replenishment. Early action should be at least 75% of the budget.", + "faqImminentCharEarlyResponse": "Early response activities: only if the disaster has unfolded, and for activities in the first hours and days following the impact of the disaster. Early response should be at most 25% of the budget.", + "faqImminentProcessQuestion": "Imminent DREF Process", + "faqImminentProcessPlanningHeading": "Planning and submission", + "faqImminentProcessPlanningTemplate": "Use the standard template, which includes the plan, budget, and optional request for Rapid Response Personnel.", + "faqImminentProcessPlanningTiming": "The request should be submitted at least 3 days before expected impact and up to one month in advance, when the event has a high likelihood of manifesting.", + "faqImminentProcessPlanningBudget": "Split the budget into a minimum of 75% for early action and up to 25% for early response.", + "faqImminentProcessPlanningBankLetter": "Attach or reference a valid Bank Letter confirming banking details to avoid delays in disbursement", + "faqImminentProcessPlanningSubmit": "Sign and submit", + "faqImminentProcessImplementationHeading": "Imminent DREF implementation", + "faqImminentProcessImplBegin": "Begin implementation immediately upon approval, with a maximum timeframe of 45 days, with no possibility for extension.", + "faqImminentProcessImplEnsure": "Ensure that early actions and early response activities are implemented according to the approved plan (using the published version, not the application document, since changes in the activities might be requested in the approval email).", + "faqImminentProcessImplFunds": "Manage funds strictly according to the allocated budget", + "faqImminentProcessImplGovernment": "The National Society may work closely with government agencies and local stakeholders to access real time hazard data and coordinate outreach to at-risk communities.", + "faqImminentProcessImplCoordinate": "During implementation, the National Society may also coordinate directly with local authorities and technical agencies to align early action efforts and ensure community needs are met effectively.", + "faqImminentProcessReportingHeading": "Imminent DREF Reporting", + "faqImminentProcessScenarioOne": "Scenario 1: The disaster does not materialize or materializes but with low impact.", + "faqImminentProcessScenarioOneReport": "Submit a Final Report (narrative and financial) within 2 months of the end of the operation.", + "faqImminentProcessScenarioOneBalance": "Return any unspent balances to the IFRC-DREF.", + "faqImminentProcessScenarioTwo": "Scenario 2: The disaster materializes with high impact and the National Society needs international financial support to assist the affected population.", + "faqImminentProcessScenarioTwoRequest": "Submit a request for an additional DREF allocation for response via an operations update. The budget cap of the 2nd allocation should include the 1st imminent DREF allocation", + "eapTabDescriptionLead": "EAPs and sEAPs are pre-approved plans that outline a National Society’s strategy for acting in advance of specific forecasted hazards.", + "eapTabDescriptionEap": "Full Early Action Protocol (EAP) is a detailed, 5-year plan that outlines a National Society’s strategy for acting in advance of specific forecasted hazards. The EAP allows for up to two activations within its implementation timeframe.", + "eapTabDescriptionSeap": "Simplified Early Action Protocol (sEAP), which offers a streamlined, two-year alternative for National Societies seeking a lighter entry point into anticipatory action. The sEAP allows for one activation only within its implementation timeframe.", + "faqFullEapQuestion": "What is an Early Action Protocol (EAP)?", + "faqFullEapIntro": "Full Early Action Protocol (EAP) is a detailed, 5-year plan that outlines a National Society's strategy for acting in advance of specific forecasted hazards.", + "faqFullEapIncludes": "The EAP includes:", + "faqFullEapBulletHazard": "A description of the hazard and risk analysis.", + "faqFullEapBulletTrigger": "A clear and concise trigger statement, including the lead time for early action.", + "faqFullEapBulletActivities": "Selection of early action activities.", + "faqFullEapBulletRoles": "Roles and responsibilities of all actors.", + "faqFullEapBulletBudget": "A detailed budget covering annual readiness activities, stock required for early action, and early action activities.", + "faqFullEapOutro": "This modality offers predictability and a robust framework for anticipatory action, supporting stronger coordination between National Societies, IFRC delegations, and partners.", + "faqEapCharacteristicsQuestion": "EAP Characteristics", + "faqEapCharPurpose": "Purpose: a comprehensive funding instrument supporting anticipatory action for weather and non-weather-related hazards with impact-based triggers for extreme events with sufficient lead times and predictable patterns.", + "faqEapCharTimeframe": "Timeframe: valid for 5 years once approved.", + "faqEapCharCoverage": "Coverage: ideally, the EAP has national coverage, however, it may also be localised coverage, depending on the context.", + "faqEapCharScale": "Scale of event: the EAP must target events that historically have had significant demonstrable humanitarian impact.", + "faqEapCharTrigger": "Trigger mechanism: based on predictions and a predefined thresholds that activate early actions in advance of a foreseen disaster (e.g. cyclone wind speed above 150 km/h; or rainfall predictions for the next 72 hours exceeding 300 mm).", + "faqEapCharTriggerEstablished": "Triggers are established during the EAP development process and validated through consultation with experts.", + "faqEapCharTriggerContext": "Triggers are very context-specific and are based on a menu of available forecasts.", + "faqEapCharTriggerDatabase": "For more information on triggers, visit the trigger database on the Anticipation Hub.", + "faqEapCharTriggerReached": "Once the trigger is reached, the National Society can immediately start implementing the early actions and request the early action fund transfer from the IFRC Delegation.", + "faqEapCharBudget": "Total budget: capped at CHF 950,000 (with two activations).", + "faqEapCharComponents": "Components: the EAP covers three components readiness, prepositioned stock and early actions:", + "faqEapCharPrepositioned": "Prepositioned stock activities: two-time (double) stock allocation; prepositioning activities aim to ensure that the National Society has the stock or materials required to implement the early action when the trigger is reached. The first procurement should be done as soon as possible after EAP approval, and the second procurement should be done as soon as possible following the first activation, in preparation for a potential second activation.", + "faqEapCharReadiness": "Readiness activities: annual capacity building actions, such as simulations and training, salaries for staff, etc., which are done throughout the EAP lifespan, ensuring the National Society has adequate capacity to implement the early action.", + "faqEapCharEarlyAction": "Early action activities: implemented within the lead time between the trigger and the hazard’s impact, ensuring timely assistance. This should be budgeted twice, to take into account the double activation.", + "faqSeapQuestion": "What is a Simplified Early Action Protocol (sEAP)?", + "faqSeapIntro": "sEAP is an additional pathway for a National Society to access pre-agreed funding from the Anticipatory Pillar of the DREF. The sEAP is “medium-term” (2 years instead of 5 years) funding alternative for a National Society who:", + "faqSeapBulletNoPartner": "does not have a partner to support the development of a full EAP and/or may not have sufficient historical data or a robust trigger model to meet the criteria for a full EAP, or", + "faqSeapBulletSmallerScale": "wishes to address an event of a smaller scale than the full EAP or", + "faqSeapBulletNewHazard": "is working on a new type of hazard for which the anticipatory action approach is still evolving.", + "faqSeapCharacteristicsQuestion": "sEAP Characteristics", + "faqSeapCharPurpose": "Purpose: a more accessible and lighter version to enable a National Society. Also applicable for weather and non-weather-related hazards.", + "faqSeapCharTimeframe": "sEAP timeframe: valid for 2 years once approved.", + "faqSeapCharCoverage": "Coverage: ideally, the sEAP has national coverage, however, it may also be localized coverage, depending on the context.", + "faqSeapCharScale": "Scale of event: the sEAP is not meant for events of seasonal average but must target events that historically have had a demonstrable humanitarian impact.", + "faqSeapCharTrigger": "Trigger mechanism: similar to the full EAP, an sEAP needs a clear and concise trigger statement with an identified forecast or expert judgement and threshold; however, less evidence is required, so it may suit hazards where there is less data available.", + "faqSeapCharBudget": "Total budget: capped at CHF 220,000 (with one activation).", + "faqSeapCharComponents": "Components: the sEAP allows National Societies to access pre-approved funding for readiness and prepositioned stock as well as funding for early action activities – same as the EAP. Based on this experience, a National Society can use the sEAP as a stepping stone, while it works on developing a full EAP.", + "faqEapProcessQuestion": "Early Action Protocols (EAPs and sEAPs) Process", + "faqEapProcessDevelopmentHeading": "Development, submission and approval process", + "faqEapProcessDevRegister": "Register the interest of the NS in developing an s/EAP through the GO Platform.", + "faqEapProcessDevAccessForm": "Access the form and complete all the sections. For a detailed overview on developing an s/EAP, consult the", + "faqEapProcessDevAccessFormLink": "Anticipatory Action Manual: A Red Cross Red Crescent Practitioners’ Guide", + "faqEapProcessDevSubmit": "Submit the s/EAP", + "faqEapProcessDevStatusUnderReview": "The status in GO will change to Under Review.", + "faqEapProcessDevInitialReview": "The initial simultaneous review by the Validation Committee will take 14 days.", + "faqEapProcessDevAddressComments": "Once the review is completed the DREF team will update the status to NS addressing comments. The National Society will have 3 months to address comments by providing detailed written response in the review checklist and edit the s/EAP form and budget as necessary. The review checklist and budget should be uploaded in GO.", + "faqEapProcessDevNoteBelowStandards": "Note: If the protocol is significantly below standards and requires much work which might take more than 3 months, the Validation Committee will close the application and ask the National Society to rework on it and submit a new version as a new application after improvement of the protocol.", + "faqEapProcessDevNextVersions": "Once a new version is submitted, the Validation Committee will take one week to review the next versions of the s/EAP. Based on the responses provided by the National Society, the Validation Committee may decide to:", + "faqEapProcessDevValidate": "Technically validate the s/EAP", + "faqEapProcessDevSupplementary": "Have supplementary questions, based on the responses/edits made by the National Society. The National Society will have one month to respond to the supplementary questions and make the necessary adjustments to the form and budget.", + "faqEapProcessDevNoteIterations": "Note: if after several iterations, the comments from the Validation Committee are not yet properly addressed and the protocol is still not considered up to standard, the Validation Committee might decide to close the application and request the National Society to rework the comments and submit a new version as a new submission after improvement.", + "faqEapProcessDevBudgetValidation": "Once the protocol is validated, the IFRC Project manager should request the validation of the budget by the Regional Finance Unit and upload in the system the validated budget.", + "faqEapProcessDevApproval": "The DREF team will process the Approval by the Appeal manager and edit the status in the GO Platform to Approved.", + "faqEapProcessManagementHeading": "s/EAP management", + "faqEapProcessAgreementHeading": "Signing of project agreement", + "faqEapProcessAgreementSign": "The National Society signs the project agreement with the IFRC.", + "faqEapProcessAgreementStatus": "When the project agreement is signed the DREF AA team will change the status to Approved.", + "faqEapProcessStockHeading": "Stock prepositioning and annual readiness", + "faqEapProcessStockProcure": "Procure and preposition stock required for early action activities (e.g., shelter strengthening kits, sandbags for flood prone areas etc.) immediately after project agreement signature.", + "faqEapProcessStockReadiness": "Conduct annual readiness activities as outlined in the approved s/EAP.", + "faqEapProcessTriggerHeading": "Trigger monitoring and activating the s/EAP", + "faqEapProcessTriggerMonitor": "Monitor forecasts and activate early actions based on pre-agreed triggers.", + "faqEapProcessTriggerAnnounce": "Announce the activation of the s/EAP via the activation template, share the activation with the DREF Operations Project Manager along with the request for payment for the early action activities.", + "faqEapProcessTriggerNoteExceptional": "Note: If the pre-agreed trigger is not reached, but the National Society has evidence that the disaster of a similar scale is imminent, the s/EAP might activate based on exceptional approval. The National Society should provide as much supporting information as possible to justify the activation. Exceptional approval will be decided on case-by-case basis.", + "faqEapProcessTriggerImplement": "Implement planned early actions reducing or mitigating the impact of the hazard for at risk communities within the lead time.", + "faqEapProcessReportingHeading": "Reporting and learning", + "faqEapProcessReportingAnnual": "Produce annual reports on the pre-positioning and readiness activities according to the reporting schedule in the Project Agreement and in line with the DREF Procedures.", + "faqEapProcessReportingIfActivated": "If the s/EAP is activated:", + "faqEapProcessReportingWorkshop": "The NS should conduct a Lessons Learned Workshop within the operational timeframe and produce a Lessons Learned Report.", + "faqEapProcessReportingActivationReport": "The National Society needs to complete an activation report, two months after the end of the activation timeframe.", + "faqEapProcessReportingFinalReport": "If the s/EAP comes to the end of the operational timeframe without an activation, the National Society should produce a Final Report.", + "faqEapProcessRevisionHeading": "Revision of the s/EAP and resubmission", + "faqEapProcessRevisionRevise": "After the activation of a sEAP or the second activation of the EAP, or after the end of the lifespan without an activation, the National Society, with support from the IFRC Delegation can revise the original s/EAP narrative and resubmit it.", + "faqEapProcessRevisionResubmit": "Once revised, the National Society focal point can resubmit to the IFRC-DREF via the GO platform for a full round of funding and another five years for an EAP or two years for a sEAP." + } +} diff --git a/app/src/views/DrefAnticipatoryPillar/index.tsx b/app/src/views/DrefAnticipatoryPillar/index.tsx new file mode 100644 index 0000000000..964199b9cb --- /dev/null +++ b/app/src/views/DrefAnticipatoryPillar/index.tsx @@ -0,0 +1,382 @@ +import { useState } from 'react'; +import { + Container, + Description, + Heading, + ListView, + Tab, + TabList, + TabPanel, + Tabs, +} from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; + +import DrefDecisionTreeCallout from '#components/domain/DrefDecisionTreeCallout'; +import DrefDocumentLink from '#components/domain/DrefDocumentLink'; +import DrefKeyResources from '#components/domain/DrefKeyResources'; +import Faq, { type FaqItem } from '#components/domain/Faq'; +import Link from '#components/Link'; +import TabPage from '#components/TabPage'; +import { DREF_TYPE_IMMINENT } from '#utils/constants'; +import { + DREF_AA_MANUAL_URL, + DREF_ANTICIPATORY_GUIDANCE_URL, + getNewDrefRouteState, +} from '#utils/domain/dref'; + +import EapMap from './EapMap'; +import EapTable from './EapTable'; +import ImminentDrefMap from './ImminentDrefMap'; +import ImminentDrefTable from './ImminentDrefTable'; + +import i18n from './i18n.json'; + +type SubTab = 'imminent' | 'eap'; + +const imminentDrefRouteState = getNewDrefRouteState(DREF_TYPE_IMMINENT); + +// eslint-disable-next-line import/prefer-default-export +export function Component() { + const strings = useTranslation(i18n); + const [activeSubTab, setActiveSubTab] = useState('imminent'); + + const imminentFaqItems: FaqItem[] = [ + { + name: 'imminentDref', + question: strings.faqImminentDrefQuestion, + answer: ( + <> +

{strings.faqImminentDrefIntro}

+

{strings.faqImminentDrefScope}

+
    +
  • {strings.faqImminentDrefBulletNotYet}
    • +
  • {strings.faqImminentDrefBulletUnfolding}
    • +
+

{strings.faqImminentDrefOutro}

+ + ), + }, + { + name: 'imminentCharacteristics', + question: strings.faqImminentCharacteristicsQuestion, + answer: ( +
    +
  • {strings.faqImminentCharTimeframe}
    • +
  • {strings.faqImminentCharTrigger}
    • +
  • + {strings.faqImminentCharThresholds} +
      +
    • {strings.faqImminentCharThresholdsNoRrp}
      • +
    • {strings.faqImminentCharThresholdsWithRrp}
      • +
    +
    • +
  • + {strings.faqImminentCharComponents} +
      +
    • {strings.faqImminentCharEarlyAction}
      • +
    • {strings.faqImminentCharEarlyResponse}
      • +
    +
    • +
+ ), + }, + { + name: 'imminentProcess', + question: strings.faqImminentProcessQuestion, + answer: ( + <> + {strings.faqImminentProcessPlanningHeading} +
    +
  • {strings.faqImminentProcessPlanningTemplate}
    • +
  • {strings.faqImminentProcessPlanningTiming}
    • +
  • {strings.faqImminentProcessPlanningBudget}
    • +
  • {strings.faqImminentProcessPlanningBankLetter}
    • +
  • {strings.faqImminentProcessPlanningSubmit}
    • +
+ {strings.faqImminentProcessImplementationHeading} +
    +
  • {strings.faqImminentProcessImplBegin}
    • +
  • {strings.faqImminentProcessImplEnsure}
    • +
  • {strings.faqImminentProcessImplFunds}
    • +
  • {strings.faqImminentProcessImplGovernment}
    • +
  • {strings.faqImminentProcessImplCoordinate}
    • +
+ {strings.faqImminentProcessReportingHeading} +
    +
  • + {strings.faqImminentProcessScenarioOne} +
      +
    • {strings.faqImminentProcessScenarioOneReport}
      • +
    • {strings.faqImminentProcessScenarioOneBalance}
      • +
    +
    • +
  • + {strings.faqImminentProcessScenarioTwo} +
      +
    • {strings.faqImminentProcessScenarioTwoRequest}
      • +
    +
    • +
+ + ), + }, + ]; + + const eapFaqItems: FaqItem[] = [ + { + name: 'fullEap', + question: strings.faqFullEapQuestion, + answer: ( + <> +

{strings.faqFullEapIntro}

+

{strings.faqFullEapIncludes}

+
    +
  • {strings.faqFullEapBulletHazard}
    • +
  • {strings.faqFullEapBulletTrigger}
    • +
  • {strings.faqFullEapBulletActivities}
    • +
  • {strings.faqFullEapBulletRoles}
    • +
  • {strings.faqFullEapBulletBudget}
    • +
+

{strings.faqFullEapOutro}

+ + ), + }, + { + name: 'eapCharacteristics', + question: strings.faqEapCharacteristicsQuestion, + answer: ( +
    +
  • {strings.faqEapCharPurpose}
    • +
  • {strings.faqEapCharTimeframe}
    • +
  • {strings.faqEapCharCoverage}
    • +
  • {strings.faqEapCharScale}
    • +
  • + {strings.faqEapCharTrigger} +
      +
    • {strings.faqEapCharTriggerEstablished}
      • +
    • {strings.faqEapCharTriggerContext}
      • +
    • {strings.faqEapCharTriggerDatabase}
      • +
    +
    • +
  • {strings.faqEapCharTriggerReached}
    • +
  • {strings.faqEapCharBudget}
    • +
  • + {strings.faqEapCharComponents} +
      +
    • {strings.faqEapCharPrepositioned}
      • +
    • {strings.faqEapCharReadiness}
      • +
    • {strings.faqEapCharEarlyAction}
      • +
    +
    • +
+ ), + }, + { + name: 'seap', + question: strings.faqSeapQuestion, + answer: ( + <> +

{strings.faqSeapIntro}

+
    +
  • {strings.faqSeapBulletNoPartner}
    • +
  • {strings.faqSeapBulletSmallerScale}
    • +
  • {strings.faqSeapBulletNewHazard}
    • +
+ + ), + }, + { + name: 'seapCharacteristics', + question: strings.faqSeapCharacteristicsQuestion, + answer: ( +
    +
  • {strings.faqSeapCharPurpose}
    • +
  • {strings.faqSeapCharTimeframe}
    • +
  • {strings.faqSeapCharCoverage}
    • +
  • {strings.faqSeapCharScale}
    • +
  • {strings.faqSeapCharTrigger}
    • +
  • {strings.faqSeapCharBudget}
    • +
  • {strings.faqSeapCharComponents}
    • +
+ ), + }, + { + name: 'eapProcess', + question: strings.faqEapProcessQuestion, + answer: ( + <> + {strings.faqEapProcessDevelopmentHeading} +
    +
  1. {strings.faqEapProcessDevRegister}
    2. +
  2. + {strings.faqEapProcessDevAccessForm} +   + + {strings.faqEapProcessDevAccessFormLink} + + . +
    3. +
  3. {strings.faqEapProcessDevSubmit}
    4. +
  4. {strings.faqEapProcessDevStatusUnderReview}
    5. +
  5. {strings.faqEapProcessDevInitialReview}
    6. +
  6. {strings.faqEapProcessDevAddressComments}
    7. +
  7. {strings.faqEapProcessDevNoteBelowStandards}
    8. +
  8. + {strings.faqEapProcessDevNextVersions} +
      +
    • {strings.faqEapProcessDevValidate}
      • +
    • {strings.faqEapProcessDevSupplementary}
      • +
    +

    {strings.faqEapProcessDevNoteIterations}

    +
    9. +
  9. {strings.faqEapProcessDevBudgetValidation}
    10. +
  10. {strings.faqEapProcessDevApproval}
    11. +
+ {strings.faqEapProcessManagementHeading} + {strings.faqEapProcessAgreementHeading} +

{strings.faqEapProcessAgreementSign}

+

{strings.faqEapProcessAgreementStatus}

+ {strings.faqEapProcessStockHeading} +
    +
  • {strings.faqEapProcessStockProcure}
    • +
  • {strings.faqEapProcessStockReadiness}
    • +
+ {strings.faqEapProcessTriggerHeading} +
    +
  • {strings.faqEapProcessTriggerMonitor}
    • +
  • + {strings.faqEapProcessTriggerAnnounce} +

    {strings.faqEapProcessTriggerNoteExceptional}

    +
    • +
  • {strings.faqEapProcessTriggerImplement}
    • +
+ {strings.faqEapProcessReportingHeading} +
    +
  • {strings.faqEapProcessReportingAnnual}
    • +
  • + {strings.faqEapProcessReportingIfActivated} +
      +
    • {strings.faqEapProcessReportingWorkshop}
      • +
    • {strings.faqEapProcessReportingActivationReport}
      • +
    +
    • +
  • {strings.faqEapProcessReportingFinalReport}
    • +
+ {strings.faqEapProcessRevisionHeading} +
    +
  • {strings.faqEapProcessRevisionRevise}
    • +
  • {strings.faqEapProcessRevisionResubmit}
    • +
+ + ), + }, + ]; + + return ( + + + + +

{strings.anticipatoryIntroOne}

+

{strings.anticipatoryIntroTwo}

+ + {/* TODO: confirm placement with design (LPF02). */} + + + + + +

{strings.imminentCardText}

+ + {strings.imminentCardButton} + + + +

{strings.eapCardText}

+ + {strings.eapCardButton} + + + + + + {strings.subTabImminent} + {strings.subTabEap} + + + + {strings.imminentTabDescription} + + + + + + + + + + +

{strings.eapTabDescriptionLead}

+

{strings.eapTabDescriptionEap}

+

{strings.eapTabDescriptionSeap}

+ + + + + + + + + + + ); +} + +Component.displayName = 'DrefAnticipatoryPillar'; diff --git a/app/src/views/DrefApplicationForm/index.tsx b/app/src/views/DrefApplicationForm/index.tsx index a843926c1a..b4ac7ae0cc 100644 --- a/app/src/views/DrefApplicationForm/index.tsx +++ b/app/src/views/DrefApplicationForm/index.tsx @@ -4,7 +4,10 @@ import { useRef, useState, } from 'react'; -import { useParams } from 'react-router-dom'; +import { + useLocation, + useParams, +} from 'react-router-dom'; import { DownloadTwoLineIcon } from '@ifrc-go/icons'; import { Button, @@ -48,6 +51,7 @@ import { DREF_STATUS_DRAFT, DREF_STATUS_FAILED, DREF_STATUS_FINALIZED, + ONSET_SUDDEN, } from '#utils/constants'; import { type GoApiResponse, @@ -78,6 +82,7 @@ import Overview from './Overview'; import drefSchema, { type DrefRequestBody, type DrefRequestPostBody, + type PartialDref, } from './schema'; import Submission from './Submission'; @@ -143,6 +148,12 @@ function getNextStep(current: DrefTabKey, direction: 1 | -1, typeOfDref: TypeOfD // eslint-disable-next-line import/prefer-default-export export function Component() { const { drefId } = useParams<{ drefId: string }>(); + const { state: navigationState } = useLocation(); + // A new DREF can be seeded with any partial form value passed via router state + // (e.g. from the DREF decision tree); an existing DREF loads from the API instead. + const initialValueFromRouteState = isNotDefined(drefId) + ? (navigationState as PartialDref | null) + : undefined; const alert = useAlert(); const { navigate } = useRouting(); @@ -184,6 +195,23 @@ export function Component() { { value: { operation_timeframe_imminent: OPERATION_TIMEFRAME_IMMINENT, + ...initialValueFromRouteState, + // Route-state seeding skips the type select's change handler, + // which derives these fields; without them the imminent-only + // inputs (proposed actions) do not render. + ...(initialValueFromRouteState?.type_of_dref === TYPE_IMMINENT ? { + type_of_onset: initialValueFromRouteState.type_of_onset ?? ONSET_SUDDEN, + proposed_action: initialValueFromRouteState.proposed_action ?? [ + { + client_id: randomString(), + proposed_type: EARLY_ACTION, + }, + { + client_id: randomString(), + proposed_type: EARLY_RESPONSE, + }, + ], + } : undefined), }, }, ); diff --git a/app/src/views/DrefDetail/i18n.json b/app/src/views/DrefDetail/i18n.json deleted file mode 100644 index 47ce2fe4c4..0000000000 --- a/app/src/views/DrefDetail/i18n.json +++ /dev/null @@ -1,15 +0,0 @@ -{ - "namespace": "drefDetail", - "strings": { - "drefIntroHeading": "DREF Intro", - "drefIntroDetailOne": "Every year, small and medium-sized disasters occur in silence. Without media attention or international visibility, they can struggle to attract funding—putting affected communities at risk of being completely neglected.", - "drefIntroDetailTwo": "To support these smaller disasters, or to provide initial funding before launching an Emergency Appeal, we rapidly channel funding to Red Cross and Red Crescent Societies through the DREF—enabling them to deliver fast and effective local humanitarian action.", - "drefProcessHeading": "Dref Process", - "drefProcessSubHeading": "We provide funding in two ways:", - "drefProcessListOne": "A loan facility: start-up funding for the IFRC and National Societies to respond to large-scale disasters, which will later be reimbursed by donor contributions to an Emergency Appeal.", - "drefProcessListTwo": "A grant facility: funding for National Society responses to small- and medium-sized disasters. This is used when no Emergency Appeal will be launched or when support from other actors is not foreseen.", - "drefProcessDetailOne": "The fund is demand-driven and locally-owned. It is open to all 191 National Societies that submit funding applications and plans of action reflecting locally identified priorities and needs.", - "drefProcessDetailTwo": "On average, the DREF supports more than 100 responses to small and medium-sized disasters every year.", - "drefDrefApplication": "DREF Application" - } -} diff --git a/app/src/views/DrefDetail/index.tsx b/app/src/views/DrefDetail/index.tsx deleted file mode 100644 index c4d6bf1f8b..0000000000 --- a/app/src/views/DrefDetail/index.tsx +++ /dev/null @@ -1,57 +0,0 @@ -import { - Container, - ListView, -} from '@ifrc-go/ui'; -import { useTranslation } from '@ifrc-go/ui/hooks'; - -import SurgeContentContainer from '#components/domain/SurgeContentContainer'; -import Link from '#components/Link'; - -import i18n from './i18n.json'; - -// eslint-disable-next-line import/prefer-default-export -export function Component() { - const strings = useTranslation(i18n); - - return ( - - - -
{strings.drefIntroDetailOne}
-
{strings.drefIntroDetailTwo}
- - -
{strings.drefProcessSubHeading}
-
    -
  • - {strings.drefProcessListOne} -
    • -
  • - {strings.drefProcessListTwo} -
    • -
-
- {strings.drefProcessDetailOne} -
-
- {strings.drefProcessDetailTwo} -
- - - {strings.drefDrefApplication} - - - - ); -} - -Component.displayName = 'DrefDetail'; diff --git a/app/src/views/DrefProcess/i18n.json b/app/src/views/DrefProcess/i18n.json deleted file mode 100644 index 01904a6dda..0000000000 --- a/app/src/views/DrefProcess/i18n.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "namespace": "drefProcess", - "strings": { - "eapHeading": "Disaster Response Emergency Fund (DREF)", - "eapDescription": "The IFRC's Disaster Emergency Fund (DREF): rapid, reliable funding for life-saving action.", - "eapProcessDrefTab": "Response And Imminent Dref", - "eapProcessEapTab": "Early Action Protocols (EAP)" - } -} diff --git a/app/src/views/DrefProcess/index.tsx b/app/src/views/DrefProcess/index.tsx deleted file mode 100644 index fb5f9c2d02..0000000000 --- a/app/src/views/DrefProcess/index.tsx +++ /dev/null @@ -1,36 +0,0 @@ -import { Outlet } from 'react-router-dom'; -import { NavigationTabList } from '@ifrc-go/ui'; -import { useTranslation } from '@ifrc-go/ui/hooks'; - -import NavigationTab from '#components/NavigationTab'; -import Page from '#components/Page'; - -import i18n from './i18n.json'; - -// eslint-disable-next-line import/prefer-default-export -export function Component() { - const strings = useTranslation(i18n); - - return ( - - - - {strings.eapProcessDrefTab} - - - {strings.eapProcessEapTab} - - - - - ); -} - -Component.displayName = 'DrefProcess'; diff --git a/app/src/views/DrefResponsePillar/DrefOperationsMap/i18n.json b/app/src/views/DrefResponsePillar/DrefOperationsMap/i18n.json new file mode 100644 index 0000000000..f254d3bdfd --- /dev/null +++ b/app/src/views/DrefResponsePillar/DrefOperationsMap/i18n.json @@ -0,0 +1,9 @@ +{ + "namespace": "drefOperationsMap", + "strings": { + "drefMapTitle": "Map of DREF operations", + "drefMapDisasterTypePlaceholder": "All Hazards", + "drefMapLegendDref": "DREF", + "drefMapFunding": "Funding requested" + } +} diff --git a/app/src/views/DrefResponsePillar/DrefOperationsMap/index.tsx b/app/src/views/DrefResponsePillar/DrefOperationsMap/index.tsx new file mode 100644 index 0000000000..9ddf18b586 --- /dev/null +++ b/app/src/views/DrefResponsePillar/DrefOperationsMap/index.tsx @@ -0,0 +1,121 @@ +import { + useCallback, + useMemo, +} from 'react'; +import { + Container, + ListView, + TextOutput, +} from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; +import { listToGroupList } from '@togglecorp/fujs'; + +import { APPEAL_TYPE_DREF } from '#components/domain/ActiveOperationMap/utils'; +import CountryPointsMap, { + type CountryPoint, + type MapLegendOption, +} from '#components/domain/CountryPointsMap'; +import DisasterTypeSelectInput from '#components/domain/DisasterTypeSelectInput'; +import useFilterState from '#hooks/useFilterState'; +import { COLOR_BLUE } from '#utils/constants'; +import { useRequest } from '#utils/restRequest'; + +import i18n from './i18n.json'; + +const MAP_LIMIT = 1000; +const now = new Date().toISOString(); + +function DrefOperationsMap() { + const strings = useTranslation(i18n); + + const { + filter, + rawFilter, + setFilterField, + } = useFilterState<{ + disasterType?: number; + }>({ + filter: {}, + }); + + const { response } = useRequest({ + url: '/api/v2/appeal/', + preserveResponse: true, + query: { + atype: APPEAL_TYPE_DREF, + dtype: filter.disasterType, + end_date__gt: now, + limit: MAP_LIMIT, + }, + }); + + const appealsByIso3 = useMemo( + () => listToGroupList( + response?.results ?? [], + (appeal) => appeal.country.iso3 ?? '', + ), + [response], + ); + + const points = useMemo( + () => Object.keys(appealsByIso3) + .filter((iso3) => iso3 !== '') + .map((iso3) => ({ iso3, color: COLOR_BLUE })), + [appealsByIso3], + ); + + const legendOptions = useMemo( + () => [{ value: APPEAL_TYPE_DREF, label: strings.drefMapLegendDref, color: COLOR_BLUE }], + [strings.drefMapLegendDref], + ); + + const renderPopup = useCallback( + (iso3: string) => { + const appeals = appealsByIso3[iso3] ?? []; + return ( + + {appeals.map((appeal) => ( + + + + ))} + + ); + }, + [appealsByIso3, strings.drefMapFunding], + ); + + return ( + + )} + > + + + ); +} + +export default DrefOperationsMap; diff --git a/app/src/views/DrefResponsePillar/DrefOperationsTable/i18n.json b/app/src/views/DrefResponsePillar/DrefOperationsTable/i18n.json new file mode 100644 index 0000000000..dc1e2b6adb --- /dev/null +++ b/app/src/views/DrefResponsePillar/DrefOperationsTable/i18n.json @@ -0,0 +1,15 @@ +{ + "namespace": "drefOperationsTable", + "strings": { + "drefOpsHeading": "DREF operations", + "drefOpsStartDate": "Start date", + "drefOpsCode": "Appeal code", + "drefOpsOperation": "Operation", + "drefOpsDisasterType": "Hazard type", + "drefOpsFunding": "Funding", + "drefOpsCountry": "Country", + "drefOpsFilterSearchPlaceholder": "Search", + "drefOpsFilterAllYears": "All Years", + "drefOpsClearFilters": "Clear Filters" + } +} diff --git a/app/src/views/DrefResponsePillar/DrefOperationsTable/index.tsx b/app/src/views/DrefResponsePillar/DrefOperationsTable/index.tsx new file mode 100644 index 0000000000..5e4583c77d --- /dev/null +++ b/app/src/views/DrefResponsePillar/DrefOperationsTable/index.tsx @@ -0,0 +1,217 @@ +import { useMemo } from 'react'; +import { SearchLineIcon } from '@ifrc-go/icons'; +import { + Button, + Container, + Pager, + SelectInput, + Table, + TextInput, +} from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; +import { + createDateColumn, + numericKeySelector, + stringValueSelector, +} from '@ifrc-go/ui/utils'; +import { isDefined } from '@togglecorp/fujs'; + +import { APPEAL_TYPE_DREF } from '#components/domain/ActiveOperationMap/utils'; +import useFilterState from '#hooks/useFilterState'; +import { + createAppealCodeColumn, + createBudgetColumn, + createCountryColumn, + createDisasterTypeColumn, + createLinkColumn, +} from '#utils/domain/tableHelpers'; +import { + type GoApiResponse, + type GoApiUrlQuery, + useRequest, +} from '#utils/restRequest'; + +import i18n from './i18n.json'; + +type AppealQueryParams = GoApiUrlQuery<'/api/v2/appeal/'>; +type AppealResponse = GoApiResponse<'/api/v2/appeal/'>; +type AppealListItem = NonNullable[number]; +type Key = AppealListItem['id']; + +const PAGE_SIZE = 10; +const FIRST_YEAR = 2018; +const now = new Date(); +const nowIso = now.toISOString(); +const yearOptions = Array.from( + { length: now.getFullYear() - FIRST_YEAR + 1 }, + (_, i) => ({ + key: now.getFullYear() - i, + value: String(now.getFullYear() - i), + }), +); +const appealKeySelector = (item: AppealListItem) => item.id; + +interface Props { + className?: string; +} + +function DrefOperationsTable(props: Props) { + const { className } = props; + const strings = useTranslation(i18n); + + const { + page, + setPage, + limit, + offset, + rawFilter, + filter, + setFilterField, + resetFilter, + rawFiltered, + filtered, + } = useFilterState<{ + search?: string, + year?: number, + }>({ + filter: {}, + pageSize: PAGE_SIZE, + }); + + const query = useMemo( + () => ({ + limit, + offset, + ordering: '-start_date', + atype: APPEAL_TYPE_DREF, + // Default view lists ongoing operations only; picking a year + // browses that year's operations including ended ones. + end_date__gt: isDefined(filter.year) ? undefined : nowIso, + search: filter.search, + start_date__gte: isDefined(filter.year) ? `${filter.year}-01-01` : undefined, + start_date__lt: isDefined(filter.year) ? `${filter.year + 1}-01-01` : undefined, + }), + [limit, offset, filter], + ); + + const { + pending, + response, + } = useRequest({ + url: '/api/v2/appeal/', + preserveResponse: true, + query, + }); + + const columns = useMemo( + () => ([ + createDateColumn( + 'start_date', + strings.drefOpsStartDate, + (item) => item.start_date, + ), + createAppealCodeColumn( + 'code', + strings.drefOpsCode, + (item) => item.code, + ), + createLinkColumn( + 'operation', + strings.drefOpsOperation, + (item) => item.name, + // NOTE: about half of DREF appeals have no linked emergency; + // without the guard the cell renders as a link that cannot resolve. + (item) => (isDefined(item.event) + ? { + to: 'emergenciesLayout', + urlParams: { emergencyId: item.event }, + } + : { + to: undefined, + withUnderline: false, + }), + ), + createDisasterTypeColumn( + 'dtype', + strings.drefOpsDisasterType, + (item) => item.dtype?.name, + ), + createBudgetColumn( + 'amount_requested', + strings.drefOpsFunding, + (item) => item.amount_requested, + ), + createCountryColumn( + 'country', + strings.drefOpsCountry, + (item) => item.country?.name, + (item) => ({ + to: 'countriesLayout', + urlParams: { countryId: item.country.id }, + }), + ), + ]), + [ + strings.drefOpsStartDate, + strings.drefOpsCode, + strings.drefOpsOperation, + strings.drefOpsDisasterType, + strings.drefOpsFunding, + strings.drefOpsCountry, + ], + ); + + return ( + + } + /> + + {rawFiltered && ( + + )} + + )} + footerActions={( + + )} + > +
+ + ); +} + +export default DrefOperationsTable; diff --git a/app/src/views/DrefResponsePillar/i18n.json b/app/src/views/DrefResponsePillar/i18n.json new file mode 100644 index 0000000000..a457c77753 --- /dev/null +++ b/app/src/views/DrefResponsePillar/i18n.json @@ -0,0 +1,99 @@ +{ + "namespace": "drefResponsePillar", + "strings": { + "responseIntro": "The Response Pillar provides funding for small- and medium-scale emergencies, whether triggered by sudden-onset events or developing slow-onset crises. It includes Response DREF grants for locally led humanitarian action and DREF Loans, which provide bridge financing for large-scale Red-category emergencies linked to an Emergency Appeal. Response DREF is a flexible mechanism, but its design may need to be adapted to the context, available evidence and operational purpose. Specific considerations apply when it is used for drought, assessments or readiness actions in situations such as epidemics, civil unrest or elections.", + "drefApplicationFormLink": "DREF Application Form", + "fullResponseGuidanceLink": "Full Response Pillar Guidance", + "faqResponseDrefQuestion": "What is a Response DREF?", + "faqResponseDrefParaOne": "The Response DREF provides rapid and flexible financial support to National Societies responding to small- and medium-scale emergencies. It can be used following a sudden-onset disaster or while a slow-onset crisis is developing, when the situation exceeds the National Society’s available capacity and requires additional humanitarian support.", + "faqResponseDrefParaTwo": "The Response DREF is designed to support locally led, needs-based action. It may fund direct humanitarian assistance, an assessment to clarify the situation and inform a later response, or activities responding to a developing crisis such as drought, food insecurity, water shortages or disease outbreaks.", + "faqResponseDrefParaThree": "The type of crisis, the available evidence and the likely scale of the response determine how the operation should be designed. Where the emergency is expected to require a broader international response, the DREF may be linked to an Emergency Appeal. In Red-level emergencies, a DREF Loan can provide bridge financing for critical start-up activities while donor contributions to the Appeal are being mobilised.", + "faqCharacteristicsQuestion": "Response DREF Characteristics", + "faqCharTimeframe": "Operating timeframe: For standard Response DREF operations, up to six months for Yellow-level emergencies and up to nine months for Orange-level emergencies. Longer timeframes apply to the Drought DREF parameter when the operation includes anticipatory, response and early recovery activities.", + "faqCharTrigger": "Trigger mechanism: a clear trigger based on credible information about the occurrence, scale or worsening impact of an emergency. Triggers may include a sudden-onset disaster, a developing slow-onset crisis, verified impact data, government declarations, disease trends, displacement figures or other evidence of humanitarian need.", + "faqCharThresholds": "Funding thresholds: up to CHF 500,000 for Yellow-level emergencies and up to CHF 1,000,000 for Orange-level emergencies. Red-level emergencies are normally addressed through an Emergency Appeal, although DREF Loan support may be considered for critical start-up activities.", + "faqCharComponents": "Components: Response DREF operations may include:", + "faqCharComponentsDirect": "Direct response activities, such as evacuations, relief distributions, cash and voucher assistance, emergency shelter, health, WASH and protection.", + "faqCharComponentsAssessments": "Emergency needs assessments when additional information is required to define the scale, targeting and priorities of the response.", + "faqCharComponentsHumanResources": "Human resources, volunteer mobilisation, logistics, monitoring, community engagement and accountability.", + "faqCharComponentsEarlyRecovery": "Early recovery activities where these are justified by the context and included within the applicable DREF parameters.", + "faqCharPlanning": "Planning and budget: the situation analysis, identified needs, operational strategy, activities, targets, indicators and budget must be consistent. Activities should be feasible for the National Society to deliver within the approved timeframe and should complement the response of authorities, Movement partners and other organisations.", + "faqCharCost": "Cost considerations: a minimum reach of 100 households, or approximately 500 people, is recommended. The indicative cost per beneficiary is CHF 150, and the recommended budget ratio is 60 per cent for direct interventions and 40 per cent for support services. These recommendations do not apply to assessment-focused or epidemic operations where the cost structure may be different.", + "faqCharConsiderations": "Specific Response DREF considerations:", + "faqCharConsiderationDroughtLink": "Drought DREF:", + "faqCharConsiderationDrought": "considerations for drought, food insecurity and water shortages, including evidence requirements, early-warning data, IPC analysis, extended timeframes and early recovery.", + "faqCharConsiderationAssessments": "DREF for Assessments: when there is insufficient information to justify or design a full response operation.", + "faqCharConsiderationReadinessLink": "Readiness actions:", + "faqCharConsiderationReadiness": "support for election readiness, civil unrest readiness and epidemic readiness when credible analysis indicates that the situation is likely to escalate.", + "faqCharConsiderationLoanLink": "DREF Loan:", + "faqCharConsiderationLoan": "bridge financing for Red-level emergencies linked to an Emergency Appeal.", + "faqResponseProcessQuestion": "Response DREF Process", + "faqProcessPlanningHeading": "Planning and submission", + "faqProcessPlanningIntro": "The Response DREF process begins when a National Society identifies a disaster or developing crisis and assesses whether external support is required.", + "faqProcessPlanningSupported": "The National Society, supported by the IFRC Delegation and relevant technical teams, should:", + "faqProcessPlanningTrigger": "identify the trigger and analyse the humanitarian situation;", + "faqProcessPlanningCapacity": "assess available National Society resources and capacity;", + "faqProcessPlanningReview": "review government, Movement and partner response;", + "faqProcessPlanningGaps": "identify remaining humanitarian gaps;", + "faqProcessPlanningAssessment": "determine whether further assessment is needed;", + "faqProcessPlanningOption": "select the appropriate DREF option;", + "faqProcessPlanningStrategy": "develop the operational strategy, indicators, workplan and budget; and", + "faqProcessPlanningEligible": "confirm that the proposed activities are eligible, feasible and proportionate.", + "faqProcessPlanningLink": "The application should link the situation analysis, identified needs, target population, planned activities and budget.", + "faqProcessPlanningSubmitted": "The application can be prepared and submitted:", + "faqProcessPlanningOnline": "online through the GO Platform using the DREF Application template; or", + "faqProcessPlanningOffline": "offline using the dedicated Excel template, which is then uploaded to GO.", + "faqProcessPlanningTiming": "Applications should be submitted as soon as possible, ideally within five days of the disaster or trigger date. Drought DREF requests must be submitted and approved within 21 days of the trigger.", + "faqProcessPlanningAdvance": "For a sudden-onset emergency requiring immediate liquidity, an Emergency Advance Payment may be requested within 24 hours while the full application is being prepared.", + "faqProcessReviewHeading": "Review, approval and disbursement", + "faqProcessReviewIntro": "Once the application is submitted, two reviews take place in parallel.", + "faqProcessReviewEligibilityHeading": "Eligibility, Compliance and Risk Management Review", + "faqProcessReviewEligibilityIntro": "This mandatory review confirms:", + "faqProcessReviewEligibilityRules": "whether the operation is eligible under DREF rules;", + "faqProcessReviewEligibilityCompliance": "whether the National Society meets the required compliance standards;", + "faqProcessReviewEligibilityBudget": "whether the budget contains eligible and non-duplicated costs; and", + "faqProcessReviewEligibilityRisks": "whether key operational, financial and delivery risks have been identified.", + "faqProcessReviewEligibilityTiming": "This review should normally be completed within 24 hours of submission.", + "faqProcessReviewQualityHeading": "Operational Quality Review", + "faqProcessReviewQualityIntro": "The Operational Quality Review assesses:", + "faqProcessReviewQualityNeeds": "the strength of the needs analysis;", + "faqProcessReviewQualityTargeting": "the appropriateness of the targeting;", + "faqProcessReviewQualityCoherence": "the coherence of the response strategy;", + "faqProcessReviewQualityFeasibility": "the feasibility of implementation;", + "faqProcessReviewQualityTechnical": "the technical quality of the activities;", + "faqProcessReviewQualityMonitoring": "the monitoring and accountability arrangements; and", + "faqProcessReviewQualityCapacity": "the capacity of the National Society to deliver the operation.", + "faqProcessReviewFinance": "Regional Finance validates the budget and confirms that the proposed costs are eligible and correctly classified.", + "faqProcessReviewComments": "The National Society responds to comments and provides revisions or clarifications where required. For sudden-onset operations, the full Operational Quality Review should normally be completed within 10 days. For slow-onset operations, it should normally be completed within 21 days of the identified trigger.", + "faqProcessReviewCompleteIntro": "Once the reviews are complete:", + "faqProcessReviewChecklist": "the Review Checklist is finalised;", + "faqProcessReviewAllocation": "the DREF Allocation Request is prepared;", + "faqProcessReviewPackage": "the final package is submitted for approval;", + "faqProcessReviewApproval": "the DREF Appeal Manager approves the application, budget and release of funds; and", + "faqProcessReviewAgreement": "the Project Agreement and payment process are completed.", + "faqProcessImplementationHeading": "Implementation, reporting and learning", + "faqProcessImplementationIntro": "The National Society leads implementation and is responsible for:", + "faqProcessImplementationDeliver": "delivering activities according to the approved plan;", + "faqProcessImplementationFunds": "managing funds in line with the approved budget;", + "faqProcessImplementationMonitor": "monitoring activities, reach and expenditure;", + "faqProcessImplementationCoordinate": "coordinating with authorities, Movement partners and other actors;", + "faqProcessImplementationCommunity": "maintaining community engagement and feedback mechanisms;", + "faqProcessImplementationUpdates": "submitting Operations Updates when changes or additional support are required; and", + "faqProcessImplementationReporting": "completing the required final reporting and closure processes.", + "faqProcessImplementationOutro": "Implementation should remain responsive to changing needs, but any material change to the operational strategy, budget or timeframe must follow the applicable DREF revision and approval process.", + "faqAdvancePaymentQuestion": "What is an Emergency Advance Payment?", + "faqAdvancePaymentIntro": "Access rapid funding within 24 hours of a sudden-onset disaster to begin lifesaving activities before your full DREF application is approved. Part of the Immediate Response Protocol (IRP), not the DREF mechanism itself.", + "faqAdvancePaymentWhenToUseTitle": "When to use", + "faqAdvancePaymentSuddenOnsetChip": "Sudden-onset only", + "faqAdvancePaymentBulletSuddenOnset": "Sudden-onset emergency requiring immediate action", + "faqAdvancePaymentBulletGoodStanding": "National Society in good standing with IFRC", + "faqAdvancePaymentBulletCriteria": "Context meets Response DREF criteria", + "faqAdvancePaymentBulletPlanning": "Planning to submit full DREF application", + "faqAdvancePaymentFunding": "Funding available", + "faqAdvancePaymentYellowLabel": "Yellow-scale events", + "faqAdvancePaymentYellowAmount": "CHF 30,000", + "faqAdvancePaymentOrangeRedLabel": "Orange/Red-scale", + "faqAdvancePaymentOrangeRedAmount": "CHF 100,000", + "faqAdvancePaymentFormLink": "Advance Payment Form" + } +} diff --git a/app/src/views/DrefResponsePillar/index.tsx b/app/src/views/DrefResponsePillar/index.tsx new file mode 100644 index 0000000000..ad808bb5d6 --- /dev/null +++ b/app/src/views/DrefResponsePillar/index.tsx @@ -0,0 +1,276 @@ +import { + Chip, + Description, + Heading, + ListView, +} from '@ifrc-go/ui'; +import { useTranslation } from '@ifrc-go/ui/hooks'; + +import DrefDecisionTreeCallout from '#components/domain/DrefDecisionTreeCallout'; +import DrefDocumentLink from '#components/domain/DrefDocumentLink'; +import DrefKeyResources from '#components/domain/DrefKeyResources'; +import Faq, { type FaqItem } from '#components/domain/Faq'; +import Link from '#components/Link'; +import TabPage from '#components/TabPage'; +import { DREF_TYPE_RESPONSE } from '#utils/constants'; +import { + DREF_ADVANCE_PAYMENT_FORM_URL, + DREF_GUIDELINES_DROUGHT_URL, + DREF_GUIDELINES_LOAN_URL, + DREF_GUIDELINES_READINESS_URL, + DREF_RESPONSE_GUIDANCE_URL, + getNewDrefRouteState, +} from '#utils/domain/dref'; + +import DrefOperationsMap from './DrefOperationsMap'; +import DrefOperationsTable from './DrefOperationsTable'; + +import i18n from './i18n.json'; +import styles from './styles.module.css'; + +const responseDrefRouteState = getNewDrefRouteState(DREF_TYPE_RESPONSE); + +// eslint-disable-next-line import/prefer-default-export +export function Component() { + const strings = useTranslation(i18n); + + const faqItems: FaqItem[] = [ + { + name: 'responseDref', + question: strings.faqResponseDrefQuestion, + answer: ( + <> +

{strings.faqResponseDrefParaOne}

+

{strings.faqResponseDrefParaTwo}

+

{strings.faqResponseDrefParaThree}

+ + ), + }, + { + name: 'characteristics', + question: strings.faqCharacteristicsQuestion, + answer: ( +
    +
  • {strings.faqCharTimeframe}
    • +
  • {strings.faqCharTrigger}
    • +
  • {strings.faqCharThresholds}
    • +
  • + {strings.faqCharComponents} +
      +
    • {strings.faqCharComponentsDirect}
      • +
    • {strings.faqCharComponentsAssessments}
      • +
    • {strings.faqCharComponentsHumanResources}
      • +
    • {strings.faqCharComponentsEarlyRecovery}
      • +
    +
    • +
  • {strings.faqCharPlanning}
    • +
  • {strings.faqCharCost}
    • +
  • + {strings.faqCharConsiderations} +
      +
    • + + {strings.faqCharConsiderationDroughtLink} + +   + {strings.faqCharConsiderationDrought} +
      • +
    • {strings.faqCharConsiderationAssessments}
      • +
    • + + {strings.faqCharConsiderationReadinessLink} + +   + {strings.faqCharConsiderationReadiness} +
      • +
    • + + {strings.faqCharConsiderationLoanLink} + +   + {strings.faqCharConsiderationLoan} +
      • +
    +
    • +
+ ), + }, + { + name: 'responseProcess', + question: strings.faqResponseProcessQuestion, + answer: ( + <> + {strings.faqProcessPlanningHeading} +

{strings.faqProcessPlanningIntro}

+

{strings.faqProcessPlanningSupported}

+
    +
  • {strings.faqProcessPlanningTrigger}
    • +
  • {strings.faqProcessPlanningCapacity}
    • +
  • {strings.faqProcessPlanningReview}
    • +
  • {strings.faqProcessPlanningGaps}
    • +
  • {strings.faqProcessPlanningAssessment}
    • +
  • {strings.faqProcessPlanningOption}
    • +
  • {strings.faqProcessPlanningStrategy}
    • +
  • {strings.faqProcessPlanningEligible}
    • +
+

{strings.faqProcessPlanningLink}

+

{strings.faqProcessPlanningSubmitted}

+
    +
  • {strings.faqProcessPlanningOnline}
    • +
  • {strings.faqProcessPlanningOffline}
    • +
+

{strings.faqProcessPlanningTiming}

+

{strings.faqProcessPlanningAdvance}

+ {strings.faqProcessReviewHeading} +

{strings.faqProcessReviewIntro}

+ {strings.faqProcessReviewEligibilityHeading} +

{strings.faqProcessReviewEligibilityIntro}

+
    +
  • {strings.faqProcessReviewEligibilityRules}
    • +
  • {strings.faqProcessReviewEligibilityCompliance}
    • +
  • {strings.faqProcessReviewEligibilityBudget}
    • +
  • {strings.faqProcessReviewEligibilityRisks}
    • +
+

{strings.faqProcessReviewEligibilityTiming}

+ {strings.faqProcessReviewQualityHeading} +

{strings.faqProcessReviewQualityIntro}

+
    +
  • {strings.faqProcessReviewQualityNeeds}
    • +
  • {strings.faqProcessReviewQualityTargeting}
    • +
  • {strings.faqProcessReviewQualityCoherence}
    • +
  • {strings.faqProcessReviewQualityFeasibility}
    • +
  • {strings.faqProcessReviewQualityTechnical}
    • +
  • {strings.faqProcessReviewQualityMonitoring}
    • +
  • {strings.faqProcessReviewQualityCapacity}
    • +
+

{strings.faqProcessReviewFinance}

+

{strings.faqProcessReviewComments}

+

{strings.faqProcessReviewCompleteIntro}

+
    +
  • {strings.faqProcessReviewChecklist}
    • +
  • {strings.faqProcessReviewAllocation}
    • +
  • {strings.faqProcessReviewPackage}
    • +
  • {strings.faqProcessReviewApproval}
    • +
  • {strings.faqProcessReviewAgreement}
    • +
+ {strings.faqProcessImplementationHeading} +

{strings.faqProcessImplementationIntro}

+
    +
  • {strings.faqProcessImplementationDeliver}
    • +
  • {strings.faqProcessImplementationFunds}
    • +
  • {strings.faqProcessImplementationMonitor}
    • +
  • {strings.faqProcessImplementationCoordinate}
    • +
  • {strings.faqProcessImplementationCommunity}
    • +
  • {strings.faqProcessImplementationUpdates}
    • +
  • {strings.faqProcessImplementationReporting}
    • +
+

{strings.faqProcessImplementationOutro}

+ + ), + }, + { + name: 'advancePayment', + question: strings.faqAdvancePaymentQuestion, + answer: ( + <> +

{strings.faqAdvancePaymentIntro}

+
+
+
+
+ {strings.faqAdvancePaymentWhenToUseTitle} +
+ +
+
    +
  • {strings.faqAdvancePaymentBulletSuddenOnset}
    • +
  • {strings.faqAdvancePaymentBulletGoodStanding}
    • +
  • {strings.faqAdvancePaymentBulletCriteria}
    • +
  • {strings.faqAdvancePaymentBulletPlanning}
    • +
+
+
+
+ {strings.faqAdvancePaymentFunding} +
+
+
{strings.faqAdvancePaymentYellowLabel}
+
+ {strings.faqAdvancePaymentYellowAmount} +
+
+
+
{strings.faqAdvancePaymentOrangeRedLabel}
+
+ {strings.faqAdvancePaymentOrangeRedAmount} +
+
+
+
+ + + + + ), + }, + ]; + + return ( + + + + {strings.responseIntro} + + + + {strings.drefApplicationFormLink} + + + + + + + + + + + ); +} + +Component.displayName = 'DrefResponsePillar'; diff --git a/app/src/views/DrefResponsePillar/styles.module.css b/app/src/views/DrefResponsePillar/styles.module.css new file mode 100644 index 0000000000..adc8cb5ece --- /dev/null +++ b/app/src/views/DrefResponsePillar/styles.module.css @@ -0,0 +1,47 @@ +.advance-payment-details { + display: grid; + grid-template-columns: 1fr 1fr; + gap: var(--go-ui-spacing-md); + + @media screen and (max-width: 40rem) { + grid-template-columns: 1fr; + } + + .block { + display: flex; + flex-direction: column; + border: var(--go-ui-width-separator-thin) solid var(--go-ui-color-separator); + border-radius: var(--go-ui-border-radius-md); + padding: var(--go-ui-spacing-md); + gap: var(--go-ui-spacing-sm); + + .block-header { + display: flex; + align-items: center; + justify-content: space-between; + gap: var(--go-ui-spacing-sm); + } + + .block-title { + font-weight: var(--go-ui-font-weight-semibold); + } + + .chip { + font-size: var(--go-ui-font-size-sm); + } + + .funding-row { + display: flex; + align-items: center; + justify-content: space-between; + border-radius: var(--go-ui-border-radius-md); + background-color: var(--go-ui-color-gray-20); + padding: var(--go-ui-spacing-2xs) var(--go-ui-spacing-sm); + gap: var(--go-ui-spacing-sm); + + .funding-amount { + font-weight: var(--go-ui-font-weight-semibold); + } + } + } +} diff --git a/app/src/views/EarlyActionProtocols/i18n.json b/app/src/views/EarlyActionProtocols/i18n.json deleted file mode 100644 index 540407ee49..0000000000 --- a/app/src/views/EarlyActionProtocols/i18n.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "namespace": "earlyActionProtocols", - "strings": { - "eapRegistrationLink": "Register your EAP", - "eapContent": "What is an EAP?", - "eapContentHeading": "Early Action Protocols (EAPs) are a core mechanism of the IFRC's Forecast-based Financing (Anticipatory Action) approach, designed to ensure that humanitarian action happens before a disaster strikes, rather than only responding afterwards.", - "eapContentSubHeadingOne": "An EAP is a pre-agreed plan developed by a Nation Society together with partners, which outlines:", - "eapDescriptionOne": "The triggers (based on scientific forecasts and risk analysis) that indicate when a hazard is likely to impact communities.", - "eapDescriptionTwo": "The early actions to be implemented once those triggers are met - practical, life-saving measures that reduce the impacts of the forecasted disaster.", - "eapDescriptionThree": "The roles, responsibilities, and budget required to carry out these actions quickly and effectively.", - "eapContentSubHeadingTwo": "Why are the EAPs Important?", - "eapContentSubHeadingThree": "What is the EAP Application Process?" - } -} diff --git a/app/src/views/EarlyActionProtocols/index.tsx b/app/src/views/EarlyActionProtocols/index.tsx deleted file mode 100644 index ee65a0fef9..0000000000 --- a/app/src/views/EarlyActionProtocols/index.tsx +++ /dev/null @@ -1,70 +0,0 @@ -import { - Container, - ExpandableContainer, - ListView, -} from '@ifrc-go/ui'; -import { useTranslation } from '@ifrc-go/ui/hooks'; - -import Link from '#components/Link'; - -import i18n from './i18n.json'; - -// eslint-disable-next-line import/prefer-default-export -export function Component() { - const strings = useTranslation(i18n); - - return ( - - {strings.eapRegistrationLink} - - )} - > - - -

- {strings.eapContentHeading} -

-

- {strings.eapContentSubHeadingOne} -

    -
  • - {strings.eapDescriptionOne} -
    • -
  • - {strings.eapDescriptionTwo} -
    • -
  • - {strings.eapDescriptionThree} -
    • -
-

- - {/* TODO: Add remaining content */} - - {/* TODO: Add real content and replace with strings */} - EAP content sub heading description two - - - {/* TODO: Add real content and replace with strings */} - EAP content sub heading description three - - - - ); -} - -Component.displayName = 'EarlyActionProtocols'; diff --git a/translationMigrations/000089-1787634374191.json b/translationMigrations/000089-1787634374191.json new file mode 100644 index 0000000000..16ec12b069 --- /dev/null +++ b/translationMigrations/000089-1787634374191.json @@ -0,0 +1,2094 @@ +{ + "parent": "000088-1786604379488.json", + "actions": [ + { + "action": "add", + "key": "userMenuDrefAnticipatoryPillar", + "namespace": "common", + "value": "Anticipatory Pillar" + }, + { + "action": "add", + "key": "userMenuDrefDecisionTree", + "namespace": "common", + "value": "DREF Decision Tree" + }, + { + "action": "add", + "key": "userMenuDrefResponsePillar", + "namespace": "common", + "value": "Response Pillar" + }, + { + "action": "update", + "key": "userMenuDrefProcess", + "namespace": "common", + "newValue": "Disaster Response Emergency Fund (DREF)" + }, + { + "action": "update", + "key": "userMenuDrefProcessDescription", + "namespace": "common", + "newValue": "The following are IFRC Applications that include Disaster Response Emergency Fund (DREF) and Early Action Protocols (EAP)." + }, + { + "action": "add", + "key": "drefAnticipatoryPillarTab", + "namespace": "dref", + "value": "Anticipatory Pillar" + }, + { + "action": "add", + "key": "drefDescription", + "namespace": "dref", + "value": "The Disaster Response Emergency Fund (DREF) provides rapid and reliable funding to National Societies to prepare for and respond to crises. This page is the main hub for understanding how DREF works, choosing the right modality, and exploring active operations." + }, + { + "action": "add", + "key": "drefHeading", + "namespace": "dref", + "value": "Disaster Response Emergency Fund (DREF)" + }, + { + "action": "add", + "key": "drefResponsePillarTab", + "namespace": "dref", + "value": "Response Pillar" + }, + { + "action": "add", + "key": "home", + "namespace": "dref", + "value": "Home" + }, + { + "action": "add", + "key": "respond", + "namespace": "dref", + "value": "Respond" + }, + { + "action": "add", + "key": "anticipatoryIntroOne", + "namespace": "drefAnticipatoryPillar", + "value": "The Anticipatory Pillar of the Disaster Response Emergency Fund (DREF) enables National Red Cross and Red Crescent Societies to act before a disaster strikes. By providing preapproving plans and budgets during peacetime, National Societies can implement anticipatory or early action activities, based on pre-agreed triggers, that aim to reduce or mitigate the humanitarian impacts of predictable hazards on at-risk communities." + }, + { + "action": "add", + "key": "anticipatoryIntroTwo", + "namespace": "drefAnticipatoryPillar", + "value": "Traditionally, humanitarian assistance was triggered only after a disaster had already caused damage. This often resulted in delayed response, increased human suffering, and greater financial costs. In contrast, anticipatory action allows the humanitarian system to shift from a reactive to a proactive model, responding to predicted disasters rather than waiting for the consequences to unfold." + }, + { + "action": "add", + "key": "eapCardButton", + "namespace": "drefAnticipatoryPillar", + "value": "Register EAP" + }, + { + "action": "add", + "key": "eapCardHeading", + "namespace": "drefAnticipatoryPillar", + "value": "Early Action Protocols (EAP)" + }, + { + "action": "add", + "key": "eapCardText", + "namespace": "drefAnticipatoryPillar", + "value": "Use this when you want to have a plan that guides the implementation of early action activities which will reduce and mitigate the humanitarian impacts of a forecasted hazard. These plans are developed and approved in peacetime, and bring together a pre-agreed plan with preapproved trigger and guaranteed funding, which gives National Society the confidence to work in advance of both weather and non-weather-related events. Two types exist: the Early Action Protocol (EAP) and the Simplified Early Action Protocol (sEAP)." + }, + { + "action": "add", + "key": "eapTabDescriptionEap", + "namespace": "drefAnticipatoryPillar", + "value": "Full Early Action Protocol (EAP) is a detailed, 5-year plan that outlines a National Society’s strategy for acting in advance of specific forecasted hazards. The EAP allows for up to two activations within its implementation timeframe." + }, + { + "action": "add", + "key": "eapTabDescriptionLead", + "namespace": "drefAnticipatoryPillar", + "value": "EAPs and sEAPs are pre-approved plans that outline a National Society’s strategy for acting in advance of specific forecasted hazards." + }, + { + "action": "add", + "key": "eapTabDescriptionSeap", + "namespace": "drefAnticipatoryPillar", + "value": "Simplified Early Action Protocol (sEAP), which offers a streamlined, two-year alternative for National Societies seeking a lighter entry point into anticipatory action. The sEAP allows for one activation only within its implementation timeframe." + }, + { + "action": "add", + "key": "faqEapCharacteristicsQuestion", + "namespace": "drefAnticipatoryPillar", + "value": "EAP Characteristics" + }, + { + "action": "add", + "key": "faqEapCharBudget", + "namespace": "drefAnticipatoryPillar", + "value": "Total budget: capped at CHF 950,000 (with two activations)." + }, + { + "action": "add", + "key": "faqEapCharComponents", + "namespace": "drefAnticipatoryPillar", + "value": "Components: the EAP covers three components readiness, prepositioned stock and early actions:" + }, + { + "action": "add", + "key": "faqEapCharCoverage", + "namespace": "drefAnticipatoryPillar", + "value": "Coverage: ideally, the EAP has national coverage, however, it may also be localised coverage, depending on the context." + }, + { + "action": "add", + "key": "faqEapCharEarlyAction", + "namespace": "drefAnticipatoryPillar", + "value": "Early action activities: implemented within the lead time between the trigger and the hazard’s impact, ensuring timely assistance. This should be budgeted twice, to take into account the double activation." + }, + { + "action": "add", + "key": "faqEapCharPrepositioned", + "namespace": "drefAnticipatoryPillar", + "value": "Prepositioned stock activities: two-time (double) stock allocation; prepositioning activities aim to ensure that the National Society has the stock or materials required to implement the early action when the trigger is reached. The first procurement should be done as soon as possible after EAP approval, and the second procurement should be done as soon as possible following the first activation, in preparation for a potential second activation." + }, + { + "action": "add", + "key": "faqEapCharPurpose", + "namespace": "drefAnticipatoryPillar", + "value": "Purpose: a comprehensive funding instrument supporting anticipatory action for weather and non-weather-related hazards with impact-based triggers for extreme events with sufficient lead times and predictable patterns." + }, + { + "action": "add", + "key": "faqEapCharReadiness", + "namespace": "drefAnticipatoryPillar", + "value": "Readiness activities: annual capacity building actions, such as simulations and training, salaries for staff, etc., which are done throughout the EAP lifespan, ensuring the National Society has adequate capacity to implement the early action." + }, + { + "action": "add", + "key": "faqEapCharScale", + "namespace": "drefAnticipatoryPillar", + "value": "Scale of event: the EAP must target events that historically have had significant demonstrable humanitarian impact." + }, + { + "action": "add", + "key": "faqEapCharTimeframe", + "namespace": "drefAnticipatoryPillar", + "value": "Timeframe: valid for 5 years once approved." + }, + { + "action": "add", + "key": "faqEapCharTrigger", + "namespace": "drefAnticipatoryPillar", + "value": "Trigger mechanism: based on predictions and a predefined thresholds that activate early actions in advance of a foreseen disaster (e.g. cyclone wind speed above 150 km/h; or rainfall predictions for the next 72 hours exceeding 300 mm)." + }, + { + "action": "add", + "key": "faqEapCharTriggerContext", + "namespace": "drefAnticipatoryPillar", + "value": "Triggers are very context-specific and are based on a menu of available forecasts." + }, + { + "action": "add", + "key": "faqEapCharTriggerDatabase", + "namespace": "drefAnticipatoryPillar", + "value": "For more information on triggers, visit the trigger database on the Anticipation Hub." + }, + { + "action": "add", + "key": "faqEapCharTriggerEstablished", + "namespace": "drefAnticipatoryPillar", + "value": "Triggers are established during the EAP development process and validated through consultation with experts." + }, + { + "action": "add", + "key": "faqEapCharTriggerReached", + "namespace": "drefAnticipatoryPillar", + "value": "Once the trigger is reached, the National Society can immediately start implementing the early actions and request the early action fund transfer from the IFRC Delegation." + }, + { + "action": "add", + "key": "faqEapProcessAgreementHeading", + "namespace": "drefAnticipatoryPillar", + "value": "Signing of project agreement" + }, + { + "action": "add", + "key": "faqEapProcessAgreementSign", + "namespace": "drefAnticipatoryPillar", + "value": "The National Society signs the project agreement with the IFRC." + }, + { + "action": "add", + "key": "faqEapProcessAgreementStatus", + "namespace": "drefAnticipatoryPillar", + "value": "When the project agreement is signed the DREF AA team will change the status to Approved." + }, + { + "action": "add", + "key": "faqEapProcessDevAccessForm", + "namespace": "drefAnticipatoryPillar", + "value": "Access the form and complete all the sections. For a detailed overview on developing an s/EAP, consult the" + }, + { + "action": "add", + "key": "faqEapProcessDevAccessFormLink", + "namespace": "drefAnticipatoryPillar", + "value": "Anticipatory Action Manual: A Red Cross Red Crescent Practitioners’ Guide" + }, + { + "action": "add", + "key": "faqEapProcessDevAddressComments", + "namespace": "drefAnticipatoryPillar", + "value": "Once the review is completed the DREF team will update the status to NS addressing comments. The National Society will have 3 months to address comments by providing detailed written response in the review checklist and edit the s/EAP form and budget as necessary. The review checklist and budget should be uploaded in GO." + }, + { + "action": "add", + "key": "faqEapProcessDevApproval", + "namespace": "drefAnticipatoryPillar", + "value": "The DREF team will process the Approval by the Appeal manager and edit the status in the GO Platform to Approved." + }, + { + "action": "add", + "key": "faqEapProcessDevBudgetValidation", + "namespace": "drefAnticipatoryPillar", + "value": "Once the protocol is validated, the IFRC Project manager should request the validation of the budget by the Regional Finance Unit and upload in the system the validated budget." + }, + { + "action": "add", + "key": "faqEapProcessDevelopmentHeading", + "namespace": "drefAnticipatoryPillar", + "value": "Development, submission and approval process" + }, + { + "action": "add", + "key": "faqEapProcessDevInitialReview", + "namespace": "drefAnticipatoryPillar", + "value": "The initial simultaneous review by the Validation Committee will take 14 days." + }, + { + "action": "add", + "key": "faqEapProcessDevNextVersions", + "namespace": "drefAnticipatoryPillar", + "value": "Once a new version is submitted, the Validation Committee will take one week to review the next versions of the s/EAP. Based on the responses provided by the National Society, the Validation Committee may decide to:" + }, + { + "action": "add", + "key": "faqEapProcessDevNoteBelowStandards", + "namespace": "drefAnticipatoryPillar", + "value": "Note: If the protocol is significantly below standards and requires much work which might take more than 3 months, the Validation Committee will close the application and ask the National Society to rework on it and submit a new version as a new application after improvement of the protocol." + }, + { + "action": "add", + "key": "faqEapProcessDevNoteIterations", + "namespace": "drefAnticipatoryPillar", + "value": "Note: if after several iterations, the comments from the Validation Committee are not yet properly addressed and the protocol is still not considered up to standard, the Validation Committee might decide to close the application and request the National Society to rework the comments and submit a new version as a new submission after improvement." + }, + { + "action": "add", + "key": "faqEapProcessDevRegister", + "namespace": "drefAnticipatoryPillar", + "value": "Register the interest of the NS in developing an s/EAP through the GO Platform." + }, + { + "action": "add", + "key": "faqEapProcessDevStatusUnderReview", + "namespace": "drefAnticipatoryPillar", + "value": "The status in GO will change to Under Review." + }, + { + "action": "add", + "key": "faqEapProcessDevSubmit", + "namespace": "drefAnticipatoryPillar", + "value": "Submit the s/EAP" + }, + { + "action": "add", + "key": "faqEapProcessDevSupplementary", + "namespace": "drefAnticipatoryPillar", + "value": "Have supplementary questions, based on the responses/edits made by the National Society. The National Society will have one month to respond to the supplementary questions and make the necessary adjustments to the form and budget." + }, + { + "action": "add", + "key": "faqEapProcessDevValidate", + "namespace": "drefAnticipatoryPillar", + "value": "Technically validate the s/EAP" + }, + { + "action": "add", + "key": "faqEapProcessManagementHeading", + "namespace": "drefAnticipatoryPillar", + "value": "s/EAP management" + }, + { + "action": "add", + "key": "faqEapProcessQuestion", + "namespace": "drefAnticipatoryPillar", + "value": "Early Action Protocols (EAPs and sEAPs) Process" + }, + { + "action": "add", + "key": "faqEapProcessReportingActivationReport", + "namespace": "drefAnticipatoryPillar", + "value": "The National Society needs to complete an activation report, two months after the end of the activation timeframe." + }, + { + "action": "add", + "key": "faqEapProcessReportingAnnual", + "namespace": "drefAnticipatoryPillar", + "value": "Produce annual reports on the pre-positioning and readiness activities according to the reporting schedule in the Project Agreement and in line with the DREF Procedures." + }, + { + "action": "add", + "key": "faqEapProcessReportingFinalReport", + "namespace": "drefAnticipatoryPillar", + "value": "If the s/EAP comes to the end of the operational timeframe without an activation, the National Society should produce a Final Report." + }, + { + "action": "add", + "key": "faqEapProcessReportingHeading", + "namespace": "drefAnticipatoryPillar", + "value": "Reporting and learning" + }, + { + "action": "add", + "key": "faqEapProcessReportingIfActivated", + "namespace": "drefAnticipatoryPillar", + "value": "If the s/EAP is activated:" + }, + { + "action": "add", + "key": "faqEapProcessReportingWorkshop", + "namespace": "drefAnticipatoryPillar", + "value": "The NS should conduct a Lessons Learned Workshop within the operational timeframe and produce a Lessons Learned Report." + }, + { + "action": "add", + "key": "faqEapProcessRevisionHeading", + "namespace": "drefAnticipatoryPillar", + "value": "Revision of the s/EAP and resubmission" + }, + { + "action": "add", + "key": "faqEapProcessRevisionResubmit", + "namespace": "drefAnticipatoryPillar", + "value": "Once revised, the National Society focal point can resubmit to the IFRC-DREF via the GO platform for a full round of funding and another five years for an EAP or two years for a sEAP." + }, + { + "action": "add", + "key": "faqEapProcessRevisionRevise", + "namespace": "drefAnticipatoryPillar", + "value": "After the activation of a sEAP or the second activation of the EAP, or after the end of the lifespan without an activation, the National Society, with support from the IFRC Delegation can revise the original s/EAP narrative and resubmit it." + }, + { + "action": "add", + "key": "faqEapProcessStockHeading", + "namespace": "drefAnticipatoryPillar", + "value": "Stock prepositioning and annual readiness" + }, + { + "action": "add", + "key": "faqEapProcessStockProcure", + "namespace": "drefAnticipatoryPillar", + "value": "Procure and preposition stock required for early action activities (e.g., shelter strengthening kits, sandbags for flood prone areas etc.) immediately after project agreement signature." + }, + { + "action": "add", + "key": "faqEapProcessStockReadiness", + "namespace": "drefAnticipatoryPillar", + "value": "Conduct annual readiness activities as outlined in the approved s/EAP." + }, + { + "action": "add", + "key": "faqEapProcessTriggerAnnounce", + "namespace": "drefAnticipatoryPillar", + "value": "Announce the activation of the s/EAP via the activation template, share the activation with the DREF Operations Project Manager along with the request for payment for the early action activities." + }, + { + "action": "add", + "key": "faqEapProcessTriggerHeading", + "namespace": "drefAnticipatoryPillar", + "value": "Trigger monitoring and activating the s/EAP" + }, + { + "action": "add", + "key": "faqEapProcessTriggerImplement", + "namespace": "drefAnticipatoryPillar", + "value": "Implement planned early actions reducing or mitigating the impact of the hazard for at risk communities within the lead time." + }, + { + "action": "add", + "key": "faqEapProcessTriggerMonitor", + "namespace": "drefAnticipatoryPillar", + "value": "Monitor forecasts and activate early actions based on pre-agreed triggers." + }, + { + "action": "add", + "key": "faqEapProcessTriggerNoteExceptional", + "namespace": "drefAnticipatoryPillar", + "value": "Note: If the pre-agreed trigger is not reached, but the National Society has evidence that the disaster of a similar scale is imminent, the s/EAP might activate based on exceptional approval. The National Society should provide as much supporting information as possible to justify the activation. Exceptional approval will be decided on case-by-case basis." + }, + { + "action": "add", + "key": "faqFullEapBulletActivities", + "namespace": "drefAnticipatoryPillar", + "value": "Selection of early action activities." + }, + { + "action": "add", + "key": "faqFullEapBulletBudget", + "namespace": "drefAnticipatoryPillar", + "value": "A detailed budget covering annual readiness activities, stock required for early action, and early action activities." + }, + { + "action": "add", + "key": "faqFullEapBulletHazard", + "namespace": "drefAnticipatoryPillar", + "value": "A description of the hazard and risk analysis." + }, + { + "action": "add", + "key": "faqFullEapBulletRoles", + "namespace": "drefAnticipatoryPillar", + "value": "Roles and responsibilities of all actors." + }, + { + "action": "add", + "key": "faqFullEapBulletTrigger", + "namespace": "drefAnticipatoryPillar", + "value": "A clear and concise trigger statement, including the lead time for early action." + }, + { + "action": "add", + "key": "faqFullEapIncludes", + "namespace": "drefAnticipatoryPillar", + "value": "The EAP includes:" + }, + { + "action": "add", + "key": "faqFullEapIntro", + "namespace": "drefAnticipatoryPillar", + "value": "Full Early Action Protocol (EAP) is a detailed, 5-year plan that outlines a National Society's strategy for acting in advance of specific forecasted hazards." + }, + { + "action": "add", + "key": "faqFullEapOutro", + "namespace": "drefAnticipatoryPillar", + "value": "This modality offers predictability and a robust framework for anticipatory action, supporting stronger coordination between National Societies, IFRC delegations, and partners." + }, + { + "action": "add", + "key": "faqFullEapQuestion", + "namespace": "drefAnticipatoryPillar", + "value": "What is an Early Action Protocol (EAP)?" + }, + { + "action": "add", + "key": "faqImminentCharacteristicsQuestion", + "namespace": "drefAnticipatoryPillar", + "value": "Imminent DREF Characteristics" + }, + { + "action": "add", + "key": "faqImminentCharComponents", + "namespace": "drefAnticipatoryPillar", + "value": "Components: no readiness and prepositioning activities as the focus is entirely on immediate early action." + }, + { + "action": "add", + "key": "faqImminentCharEarlyAction", + "namespace": "drefAnticipatoryPillar", + "value": "Early action activities: activities which will prevent or mitigate the expected impact of the disaster. Early action activities are time-sensitive and must be implemented rapidly in advance of the hazard. National Societies may include items procurement for immediate use, or replenishment. Early action should be at least 75% of the budget." + }, + { + "action": "add", + "key": "faqImminentCharEarlyResponse", + "namespace": "drefAnticipatoryPillar", + "value": "Early response activities: only if the disaster has unfolded, and for activities in the first hours and days following the impact of the disaster. Early response should be at most 25% of the budget." + }, + { + "action": "add", + "key": "faqImminentCharThresholds", + "namespace": "drefAnticipatoryPillar", + "value": "Total allocation thresholds capped at:" + }, + { + "action": "add", + "key": "faqImminentCharThresholdsNoRrp", + "namespace": "drefAnticipatoryPillar", + "value": "CHF 80,000, if Rapid Response Personnel (RRP) is not requested. In this case, the Imminent DREF does not include an allocation for IFRC direct costs, it is solely for the National Society." + }, + { + "action": "add", + "key": "faqImminentCharThresholdsWithRrp", + "namespace": "drefAnticipatoryPillar", + "value": "CHF 90,800, if Rapid Response Personnel (RRP) was requested. In this case, the Imminent DREF includes IFRC direct costs for deployment of Rapid Response Personnel." + }, + { + "action": "add", + "key": "faqImminentCharTimeframe", + "namespace": "drefAnticipatoryPillar", + "value": "Operating timeframe: 45 days, with no possibility of extension." + }, + { + "action": "add", + "key": "faqImminentCharTrigger", + "namespace": "drefAnticipatoryPillar", + "value": "Trigger mechanism: no pre-agreed trigger; decision is driven by high-confidence forecasts or expert judgement of an imminent event (e.g. a government or national/regional weather agency issues a severe weather alert for a specific area with high certainty)." + }, + { + "action": "add", + "key": "faqImminentDrefBulletNotYet", + "namespace": "drefAnticipatoryPillar", + "value": "A disaster has not yet occurred, but is highly likely to happen in the near future based on reliable forecasts or early warnings; or" + }, + { + "action": "add", + "key": "faqImminentDrefBulletUnfolding", + "namespace": "drefAnticipatoryPillar", + "value": "A disaster has begun to unfold, but has not yet reached its peak impact, and there remains a short lead time to mitigate the worst effects." + }, + { + "action": "add", + "key": "faqImminentDrefIntro", + "namespace": "drefAnticipatoryPillar", + "value": "Imminent DREF is specifically designed for situations where a National Society does not have a pre-approved Early Action Protocol (EAP) or Simplified EAP (sEAP) but has the opportunity to implement early action in advance of a hazard that is clearly on the horizon." + }, + { + "action": "add", + "key": "faqImminentDrefOutro", + "namespace": "drefAnticipatoryPillar", + "value": "Imminent DREF should not be a replacement for longer-term anticipatory planning. Rather, it serves as a critical stopgap in situations where the National Society has had no time or resources to formalize a pre-approved protocol. It is also an entry point for a National Society who is still in the process of developing an s/EAP or has an EAP in place which covers a higher scale of disaster." + }, + { + "action": "add", + "key": "faqImminentDrefQuestion", + "namespace": "drefAnticipatoryPillar", + "value": "What is an Imminent DREF?" + }, + { + "action": "add", + "key": "faqImminentDrefScope", + "namespace": "drefAnticipatoryPillar", + "value": "This modality is intended exclusively for sudden-onset disasters where the risk of disaster is clear and imminent, but where the window to act is extremely limited. It enables National Societies to implement critical early action and early response actions when:" + }, + { + "action": "add", + "key": "faqImminentProcessImplBegin", + "namespace": "drefAnticipatoryPillar", + "value": "Begin implementation immediately upon approval, with a maximum timeframe of 45 days, with no possibility for extension." + }, + { + "action": "add", + "key": "faqImminentProcessImplCoordinate", + "namespace": "drefAnticipatoryPillar", + "value": "During implementation, the National Society may also coordinate directly with local authorities and technical agencies to align early action efforts and ensure community needs are met effectively." + }, + { + "action": "add", + "key": "faqImminentProcessImplementationHeading", + "namespace": "drefAnticipatoryPillar", + "value": "Imminent DREF implementation" + }, + { + "action": "add", + "key": "faqImminentProcessImplEnsure", + "namespace": "drefAnticipatoryPillar", + "value": "Ensure that early actions and early response activities are implemented according to the approved plan (using the published version, not the application document, since changes in the activities might be requested in the approval email)." + }, + { + "action": "add", + "key": "faqImminentProcessImplFunds", + "namespace": "drefAnticipatoryPillar", + "value": "Manage funds strictly according to the allocated budget" + }, + { + "action": "add", + "key": "faqImminentProcessImplGovernment", + "namespace": "drefAnticipatoryPillar", + "value": "The National Society may work closely with government agencies and local stakeholders to access real time hazard data and coordinate outreach to at-risk communities." + }, + { + "action": "add", + "key": "faqImminentProcessPlanningBankLetter", + "namespace": "drefAnticipatoryPillar", + "value": "Attach or reference a valid Bank Letter confirming banking details to avoid delays in disbursement" + }, + { + "action": "add", + "key": "faqImminentProcessPlanningBudget", + "namespace": "drefAnticipatoryPillar", + "value": "Split the budget into a minimum of 75% for early action and up to 25% for early response." + }, + { + "action": "add", + "key": "faqImminentProcessPlanningHeading", + "namespace": "drefAnticipatoryPillar", + "value": "Planning and submission" + }, + { + "action": "add", + "key": "faqImminentProcessPlanningSubmit", + "namespace": "drefAnticipatoryPillar", + "value": "Sign and submit" + }, + { + "action": "add", + "key": "faqImminentProcessPlanningTemplate", + "namespace": "drefAnticipatoryPillar", + "value": "Use the standard template, which includes the plan, budget, and optional request for Rapid Response Personnel." + }, + { + "action": "add", + "key": "faqImminentProcessPlanningTiming", + "namespace": "drefAnticipatoryPillar", + "value": "The request should be submitted at least 3 days before expected impact and up to one month in advance, when the event has a high likelihood of manifesting." + }, + { + "action": "add", + "key": "faqImminentProcessQuestion", + "namespace": "drefAnticipatoryPillar", + "value": "Imminent DREF Process" + }, + { + "action": "add", + "key": "faqImminentProcessReportingHeading", + "namespace": "drefAnticipatoryPillar", + "value": "Imminent DREF Reporting" + }, + { + "action": "add", + "key": "faqImminentProcessScenarioOne", + "namespace": "drefAnticipatoryPillar", + "value": "Scenario 1: The disaster does not materialize or materializes but with low impact." + }, + { + "action": "add", + "key": "faqImminentProcessScenarioOneBalance", + "namespace": "drefAnticipatoryPillar", + "value": "Return any unspent balances to the IFRC-DREF." + }, + { + "action": "add", + "key": "faqImminentProcessScenarioOneReport", + "namespace": "drefAnticipatoryPillar", + "value": "Submit a Final Report (narrative and financial) within 2 months of the end of the operation." + }, + { + "action": "add", + "key": "faqImminentProcessScenarioTwo", + "namespace": "drefAnticipatoryPillar", + "value": "Scenario 2: The disaster materializes with high impact and the National Society needs international financial support to assist the affected population." + }, + { + "action": "add", + "key": "faqImminentProcessScenarioTwoRequest", + "namespace": "drefAnticipatoryPillar", + "value": "Submit a request for an additional DREF allocation for response via an operations update. The budget cap of the 2nd allocation should include the 1st imminent DREF allocation" + }, + { + "action": "add", + "key": "faqSeapBulletNewHazard", + "namespace": "drefAnticipatoryPillar", + "value": "is working on a new type of hazard for which the anticipatory action approach is still evolving." + }, + { + "action": "add", + "key": "faqSeapBulletNoPartner", + "namespace": "drefAnticipatoryPillar", + "value": "does not have a partner to support the development of a full EAP and/or may not have sufficient historical data or a robust trigger model to meet the criteria for a full EAP, or" + }, + { + "action": "add", + "key": "faqSeapBulletSmallerScale", + "namespace": "drefAnticipatoryPillar", + "value": "wishes to address an event of a smaller scale than the full EAP or" + }, + { + "action": "add", + "key": "faqSeapCharacteristicsQuestion", + "namespace": "drefAnticipatoryPillar", + "value": "sEAP Characteristics" + }, + { + "action": "add", + "key": "faqSeapCharBudget", + "namespace": "drefAnticipatoryPillar", + "value": "Total budget: capped at CHF 220,000 (with one activation)." + }, + { + "action": "add", + "key": "faqSeapCharComponents", + "namespace": "drefAnticipatoryPillar", + "value": "Components: the sEAP allows National Societies to access pre-approved funding for readiness and prepositioned stock as well as funding for early action activities – same as the EAP. Based on this experience, a National Society can use the sEAP as a stepping stone, while it works on developing a full EAP." + }, + { + "action": "add", + "key": "faqSeapCharCoverage", + "namespace": "drefAnticipatoryPillar", + "value": "Coverage: ideally, the sEAP has national coverage, however, it may also be localized coverage, depending on the context." + }, + { + "action": "add", + "key": "faqSeapCharPurpose", + "namespace": "drefAnticipatoryPillar", + "value": "Purpose: a more accessible and lighter version to enable a National Society. Also applicable for weather and non-weather-related hazards." + }, + { + "action": "add", + "key": "faqSeapCharScale", + "namespace": "drefAnticipatoryPillar", + "value": "Scale of event: the sEAP is not meant for events of seasonal average but must target events that historically have had a demonstrable humanitarian impact." + }, + { + "action": "add", + "key": "faqSeapCharTimeframe", + "namespace": "drefAnticipatoryPillar", + "value": "sEAP timeframe: valid for 2 years once approved." + }, + { + "action": "add", + "key": "faqSeapCharTrigger", + "namespace": "drefAnticipatoryPillar", + "value": "Trigger mechanism: similar to the full EAP, an sEAP needs a clear and concise trigger statement with an identified forecast or expert judgement and threshold; however, less evidence is required, so it may suit hazards where there is less data available." + }, + { + "action": "add", + "key": "faqSeapIntro", + "namespace": "drefAnticipatoryPillar", + "value": "sEAP is an additional pathway for a National Society to access pre-agreed funding from the Anticipatory Pillar of the DREF. The sEAP is “medium-term” (2 years instead of 5 years) funding alternative for a National Society who:" + }, + { + "action": "add", + "key": "faqSeapQuestion", + "namespace": "drefAnticipatoryPillar", + "value": "What is a Simplified Early Action Protocol (sEAP)?" + }, + { + "action": "add", + "key": "fullAnticipatoryGuidanceLink", + "namespace": "drefAnticipatoryPillar", + "value": "Full Anticipatory Pillar Guidance" + }, + { + "action": "add", + "key": "imminentCardButton", + "namespace": "drefAnticipatoryPillar", + "value": "Start Imminent DREF" + }, + { + "action": "add", + "key": "imminentCardHeading", + "namespace": "drefAnticipatoryPillar", + "value": "Imminent DREF" + }, + { + "action": "add", + "key": "imminentCardText", + "namespace": "drefAnticipatoryPillar", + "value": "Use this for sudden-onset disasters only, when the event has not materialized yet and the National Society has no Early Action Protocol in place to act ahead. The template is short and approval is quick, so your decision-making has to be quick too." + }, + { + "action": "add", + "key": "imminentTabDescription", + "namespace": "drefAnticipatoryPillar", + "value": "Imminent DREF is meant for sudden-onset disasters only and can be used in the context where a disaster has not started to unfold, but has a high likelihood of happening, or a disaster which has started to unfold and has not reached its full impact yet. An imminent DREF has a short and simple request template and a quick approval process, but requires strong decision-making processes to ensure timely implementation." + }, + { + "action": "add", + "key": "subTabEap", + "namespace": "drefAnticipatoryPillar", + "value": "Early Action Protocols" + }, + { + "action": "add", + "key": "subTabImminent", + "namespace": "drefAnticipatoryPillar", + "value": "Imminent DREF" + }, + { + "action": "add", + "key": "backButton", + "namespace": "drefDecisionTree", + "value": "Back" + }, + { + "action": "add", + "key": "deadEndMessage", + "namespace": "drefDecisionTree", + "value": "No recommendation is configured for this path yet. Please coordinate with your Delegation and DREF Focal Point." + }, + { + "action": "add", + "key": "disclaimer", + "namespace": "drefDecisionTree", + "value": "For guidance purposes only, and under consideration that both the National Society and the disaster are eligible for DREF. Always coordinate with your Delegation and DREF Focal Point." + }, + { + "action": "add", + "key": "drefApplicationFormButton", + "namespace": "drefDecisionTree", + "value": "DREF Application Form" + }, + { + "action": "add", + "key": "drefGuidelinesButton", + "namespace": "drefDecisionTree", + "value": "DREF Guidelines" + }, + { + "action": "add", + "key": "eapDevelopmentRegistrationButton", + "namespace": "drefDecisionTree", + "value": "Early Action Protocol Development Registration" + }, + { + "action": "add", + "key": "nextButton", + "namespace": "drefDecisionTree", + "value": "Next" + }, + { + "action": "add", + "key": "noteAdvancePayment", + "namespace": "drefDecisionTree", + "value": "As this is a sudden-onset event, your National Society may also request an advance payment while developing the DREF Application." + }, + { + "action": "add", + "key": "noteConductAssessment", + "namespace": "drefDecisionTree", + "value": "If not using the Assessment-type DREF Application form, conduct a further assessment before applying for DREF." + }, + { + "action": "add", + "key": "noteEapActivationByEmail", + "namespace": "drefDecisionTree", + "value": "Please note that currently the EAP Activation process cannot be done through the IFRC GO platform. Kindly submit your activation notification through the following email address: dref.anticipatorypillar@ifrc.org" + }, + { + "action": "add", + "key": "noteEmergencyAppealUnavailable", + "namespace": "drefDecisionTree", + "value": "Please note that currently Emergency Appeals cannot be done through the IFRC GO platform." + }, + { + "action": "add", + "key": "noteInsufficientEvidence", + "namespace": "drefDecisionTree", + "value": "If evidence is insufficient to justify a full response, consider an Assessment DREF allocation first to generate the necessary evidence before scaling up the intervention." + }, + { + "action": "add", + "key": "noteJustifyExceptionalApproval", + "namespace": "drefDecisionTree", + "value": "Make sure to include all the necessary information to justify the exceptional approval." + }, + { + "action": "add", + "key": "noteLinkFollowingResources", + "namespace": "drefDecisionTree", + "value": "Check the following resources for more details." + }, + { + "action": "add", + "key": "noteLinkLearnMore", + "namespace": "drefDecisionTree", + "value": "Click here to learn more." + }, + { + "action": "add", + "key": "noteRecurrentEvents", + "namespace": "drefDecisionTree", + "value": "For recurrent events, your National Society may need to provide additional information or justification for the use of DREF." + }, + { + "action": "add", + "key": "optionNatureSlow", + "namespace": "drefDecisionTree", + "value": "Slow Onset Emergency" + }, + { + "action": "add", + "key": "optionNatureSudden", + "namespace": "drefDecisionTree", + "value": "Sudden Onset Emergency" + }, + { + "action": "add", + "key": "optionNo", + "namespace": "drefDecisionTree", + "value": "No" + }, + { + "action": "add", + "key": "optionSizeLarge", + "namespace": "drefDecisionTree", + "value": "Large-scale emergency requiring broader support" + }, + { + "action": "add", + "key": "optionSizeSmall", + "namespace": "drefDecisionTree", + "value": "Small/medium-scale emergency" + }, + { + "action": "add", + "key": "optionYes", + "namespace": "drefDecisionTree", + "value": "Yes" + }, + { + "action": "add", + "key": "outcomeAssessmentDref", + "namespace": "drefDecisionTree", + "value": "Consider Assessment DREF" + }, + { + "action": "add", + "key": "outcomeDevelopEap", + "namespace": "drefDecisionTree", + "value": "Consider developing an Early Action Protocol" + }, + { + "action": "add", + "key": "outcomeDroughtDref", + "namespace": "drefDecisionTree", + "value": "Consider Response DREF focused on Drought disaster type" + }, + { + "action": "add", + "key": "outcomeEapActivation", + "namespace": "drefDecisionTree", + "value": "Consider EAP Activation" + }, + { + "action": "add", + "key": "outcomeEmergencyAppeal", + "namespace": "drefDecisionTree", + "value": "Consider Emergency Appeal" + }, + { + "action": "add", + "key": "outcomeExceptionalApproval", + "namespace": "drefDecisionTree", + "value": "Potentially eligible for exceptional approval for the EAP Activation" + }, + { + "action": "add", + "key": "outcomeImminentDref", + "namespace": "drefDecisionTree", + "value": "Consider Imminent DREF" + }, + { + "action": "add", + "key": "outcomeResponseDref", + "namespace": "drefDecisionTree", + "value": "Consider Response DREF" + }, + { + "action": "add", + "key": "questionAlertIssued", + "namespace": "drefDecisionTree", + "value": "Has an alert been issued?" + }, + { + "action": "add", + "key": "questionAlertRelated", + "namespace": "drefDecisionTree", + "value": "Is the alert related to a slow-onset hazard, civil unrest, election readiness or epidemic?" + }, + { + "action": "add", + "key": "questionDroughtFocusAnticipatory", + "namespace": "drefDecisionTree", + "value": "Are you anticipating specifically the impacts of drought, food insecurity, or water shortages?" + }, + { + "action": "add", + "key": "questionDroughtFocusResponse", + "namespace": "drefDecisionTree", + "value": "Are you responding specifically to drought, food insecurity, or water shortages?" + }, + { + "action": "add", + "key": "questionEapTrigger", + "namespace": "drefDecisionTree", + "value": "Has the pre-agreed trigger of the EAP been reached?" + }, + { + "action": "add", + "key": "questionEnoughInfo", + "namespace": "drefDecisionTree", + "value": "Do you have enough information to justify the response?" + }, + { + "action": "add", + "key": "questionEventOccurred", + "namespace": "drefDecisionTree", + "value": "Has the event already occurred?" + }, + { + "action": "add", + "key": "questionGeoCoverage", + "namespace": "drefDecisionTree", + "value": "Is the geographical coverage the same as indicated in the EAP?" + }, + { + "action": "add", + "key": "questionHasEap", + "namespace": "drefDecisionTree", + "value": "Does the National Society have an Early Action Protocol in place?" + }, + { + "action": "add", + "key": "questionNature", + "namespace": "drefDecisionTree", + "value": "What is the nature of the disaster?" + }, + { + "action": "add", + "key": "questionRiskThreshold", + "namespace": "drefDecisionTree", + "value": "Is the level of risk similar to the EAP threshold?" + }, + { + "action": "add", + "key": "questionSize", + "namespace": "drefDecisionTree", + "value": "What size of operation are you aiming at?" + }, + { + "action": "add", + "key": "restartButton", + "namespace": "drefDecisionTree", + "value": "Restart" + }, + { + "action": "add", + "key": "title", + "namespace": "drefDecisionTree", + "value": "DREF DECISION TREE - DREF FUNDING OPTIONS" + }, + { + "action": "add", + "key": "drefDecisionTreeButtonLabel", + "namespace": "drefDecisionTreeButton", + "value": "DREF Decision Tree" + }, + { + "action": "add", + "key": "decisionTreeCalloutDescription", + "namespace": "drefDecisionTreeCallout", + "value": "If you are not sure which DREF application (response or anticipatory) best fits your situation, use the following decision tree, which will help you with your selection." + }, + { + "action": "add", + "key": "decisionTreeCalloutHeading", + "namespace": "drefDecisionTreeCallout", + "value": "DREF Decision Tree" + }, + { + "action": "remove", + "key": "drefDrefApplication", + "namespace": "drefDetail" + }, + { + "action": "remove", + "key": "drefIntroDetailOne", + "namespace": "drefDetail" + }, + { + "action": "remove", + "key": "drefIntroDetailTwo", + "namespace": "drefDetail" + }, + { + "action": "remove", + "key": "drefIntroHeading", + "namespace": "drefDetail" + }, + { + "action": "remove", + "key": "drefProcessDetailOne", + "namespace": "drefDetail" + }, + { + "action": "remove", + "key": "drefProcessDetailTwo", + "namespace": "drefDetail" + }, + { + "action": "remove", + "key": "drefProcessHeading", + "namespace": "drefDetail" + }, + { + "action": "remove", + "key": "drefProcessListOne", + "namespace": "drefDetail" + }, + { + "action": "remove", + "key": "drefProcessListTwo", + "namespace": "drefDetail" + }, + { + "action": "remove", + "key": "drefProcessSubHeading", + "namespace": "drefDetail" + }, + { + "action": "add", + "key": "aaManualDescription", + "namespace": "drefKeyResources", + "value": "A detailed overview on how to develop an Early Action Protocol." + }, + { + "action": "add", + "key": "aaManualName", + "namespace": "drefKeyResources", + "value": "AA Manual" + }, + { + "action": "add", + "key": "anticipationHubDescription", + "namespace": "drefKeyResources", + "value": "A wealth of resources available on anticipatory action for a range of stakeholders." + }, + { + "action": "add", + "key": "anticipationHubName", + "namespace": "drefKeyResources", + "value": "Anticipation Hub Website" + }, + { + "action": "add", + "key": "drefGuidelinesDescription", + "namespace": "drefKeyResources", + "value": "Detailed technical guidance covering eligibility criteria, activity design, budget planning, and implementation standards." + }, + { + "action": "add", + "key": "drefGuidelinesName", + "namespace": "drefKeyResources", + "value": "DREF Guidelines" + }, + { + "action": "add", + "key": "drefProceduresDescription", + "namespace": "drefKeyResources", + "value": "Comprehensive operational procedures for all DREF modalities including application, approval, and reporting requirements." + }, + { + "action": "add", + "key": "drefProceduresName", + "namespace": "drefKeyResources", + "value": "DREF Procedures" + }, + { + "action": "add", + "key": "erfDescription", + "namespace": "drefKeyResources", + "value": "Official Framework which determines the mechanisms, roles and responsibilities, as well as operational pathways for IFRC supported operations." + }, + { + "action": "add", + "key": "erfName", + "namespace": "drefKeyResources", + "value": "Emergency Response Framework (ERF)" + }, + { + "action": "add", + "key": "keyResourcesHeading", + "namespace": "drefKeyResources", + "value": "Key DREF resources" + }, + { + "action": "add", + "key": "openDocument", + "namespace": "drefKeyResources", + "value": "Open document" + }, + { + "action": "add", + "key": "rbmDescription", + "namespace": "drefKeyResources", + "value": "Guidance on results-based planning, monitoring, reporting, and operational learning for DREF operations, helping teams deliver measurable, accountable, and effective humanitarian responses." + }, + { + "action": "add", + "key": "rbmName", + "namespace": "drefKeyResources", + "value": "Results-Based Management (RBM)" + }, + { + "action": "add", + "key": "drefMapDisasterTypePlaceholder", + "namespace": "drefOperationsMap", + "value": "All Hazards" + }, + { + "action": "add", + "key": "drefMapFunding", + "namespace": "drefOperationsMap", + "value": "Funding requested" + }, + { + "action": "add", + "key": "drefMapLegendDref", + "namespace": "drefOperationsMap", + "value": "DREF" + }, + { + "action": "add", + "key": "drefMapTitle", + "namespace": "drefOperationsMap", + "value": "Map of DREF operations" + }, + { + "action": "add", + "key": "drefOpsClearFilters", + "namespace": "drefOperationsTable", + "value": "Clear Filters" + }, + { + "action": "add", + "key": "drefOpsCode", + "namespace": "drefOperationsTable", + "value": "Appeal code" + }, + { + "action": "add", + "key": "drefOpsCountry", + "namespace": "drefOperationsTable", + "value": "Country" + }, + { + "action": "add", + "key": "drefOpsDisasterType", + "namespace": "drefOperationsTable", + "value": "Hazard type" + }, + { + "action": "add", + "key": "drefOpsFilterAllYears", + "namespace": "drefOperationsTable", + "value": "All Years" + }, + { + "action": "add", + "key": "drefOpsFilterSearchPlaceholder", + "namespace": "drefOperationsTable", + "value": "Search" + }, + { + "action": "add", + "key": "drefOpsFunding", + "namespace": "drefOperationsTable", + "value": "Funding" + }, + { + "action": "add", + "key": "drefOpsHeading", + "namespace": "drefOperationsTable", + "value": "DREF operations" + }, + { + "action": "add", + "key": "drefOpsOperation", + "namespace": "drefOperationsTable", + "value": "Operation" + }, + { + "action": "add", + "key": "drefOpsStartDate", + "namespace": "drefOperationsTable", + "value": "Start date" + }, + { + "action": "remove", + "key": "eapDescription", + "namespace": "drefProcess" + }, + { + "action": "remove", + "key": "eapHeading", + "namespace": "drefProcess" + }, + { + "action": "remove", + "key": "eapProcessDrefTab", + "namespace": "drefProcess" + }, + { + "action": "remove", + "key": "eapProcessEapTab", + "namespace": "drefProcess" + }, + { + "action": "add", + "key": "drefApplicationFormLink", + "namespace": "drefResponsePillar", + "value": "DREF Application Form" + }, + { + "action": "add", + "key": "faqAdvancePaymentBulletCriteria", + "namespace": "drefResponsePillar", + "value": "Context meets Response DREF criteria" + }, + { + "action": "add", + "key": "faqAdvancePaymentBulletGoodStanding", + "namespace": "drefResponsePillar", + "value": "National Society in good standing with IFRC" + }, + { + "action": "add", + "key": "faqAdvancePaymentBulletPlanning", + "namespace": "drefResponsePillar", + "value": "Planning to submit full DREF application" + }, + { + "action": "add", + "key": "faqAdvancePaymentBulletSuddenOnset", + "namespace": "drefResponsePillar", + "value": "Sudden-onset emergency requiring immediate action" + }, + { + "action": "add", + "key": "faqAdvancePaymentFormLink", + "namespace": "drefResponsePillar", + "value": "Advance Payment Form" + }, + { + "action": "add", + "key": "faqAdvancePaymentFunding", + "namespace": "drefResponsePillar", + "value": "Funding available" + }, + { + "action": "add", + "key": "faqAdvancePaymentIntro", + "namespace": "drefResponsePillar", + "value": "Access rapid funding within 24 hours of a sudden-onset disaster to begin lifesaving activities before your full DREF application is approved. Part of the Immediate Response Protocol (IRP), not the DREF mechanism itself." + }, + { + "action": "add", + "key": "faqAdvancePaymentOrangeRedAmount", + "namespace": "drefResponsePillar", + "value": "CHF 100,000" + }, + { + "action": "add", + "key": "faqAdvancePaymentOrangeRedLabel", + "namespace": "drefResponsePillar", + "value": "Orange/Red-scale" + }, + { + "action": "add", + "key": "faqAdvancePaymentQuestion", + "namespace": "drefResponsePillar", + "value": "What is an Emergency Advance Payment?" + }, + { + "action": "add", + "key": "faqAdvancePaymentSuddenOnsetChip", + "namespace": "drefResponsePillar", + "value": "Sudden-onset only" + }, + { + "action": "add", + "key": "faqAdvancePaymentWhenToUseTitle", + "namespace": "drefResponsePillar", + "value": "When to use" + }, + { + "action": "add", + "key": "faqAdvancePaymentYellowAmount", + "namespace": "drefResponsePillar", + "value": "CHF 30,000" + }, + { + "action": "add", + "key": "faqAdvancePaymentYellowLabel", + "namespace": "drefResponsePillar", + "value": "Yellow-scale events" + }, + { + "action": "add", + "key": "faqCharacteristicsQuestion", + "namespace": "drefResponsePillar", + "value": "Response DREF Characteristics" + }, + { + "action": "add", + "key": "faqCharComponents", + "namespace": "drefResponsePillar", + "value": "Components: Response DREF operations may include:" + }, + { + "action": "add", + "key": "faqCharComponentsAssessments", + "namespace": "drefResponsePillar", + "value": "Emergency needs assessments when additional information is required to define the scale, targeting and priorities of the response." + }, + { + "action": "add", + "key": "faqCharComponentsDirect", + "namespace": "drefResponsePillar", + "value": "Direct response activities, such as evacuations, relief distributions, cash and voucher assistance, emergency shelter, health, WASH and protection." + }, + { + "action": "add", + "key": "faqCharComponentsEarlyRecovery", + "namespace": "drefResponsePillar", + "value": "Early recovery activities where these are justified by the context and included within the applicable DREF parameters." + }, + { + "action": "add", + "key": "faqCharComponentsHumanResources", + "namespace": "drefResponsePillar", + "value": "Human resources, volunteer mobilisation, logistics, monitoring, community engagement and accountability." + }, + { + "action": "add", + "key": "faqCharConsiderationAssessments", + "namespace": "drefResponsePillar", + "value": "DREF for Assessments: when there is insufficient information to justify or design a full response operation." + }, + { + "action": "add", + "key": "faqCharConsiderationDrought", + "namespace": "drefResponsePillar", + "value": "considerations for drought, food insecurity and water shortages, including evidence requirements, early-warning data, IPC analysis, extended timeframes and early recovery." + }, + { + "action": "add", + "key": "faqCharConsiderationDroughtLink", + "namespace": "drefResponsePillar", + "value": "Drought DREF:" + }, + { + "action": "add", + "key": "faqCharConsiderationLoan", + "namespace": "drefResponsePillar", + "value": "bridge financing for Red-level emergencies linked to an Emergency Appeal." + }, + { + "action": "add", + "key": "faqCharConsiderationLoanLink", + "namespace": "drefResponsePillar", + "value": "DREF Loan:" + }, + { + "action": "add", + "key": "faqCharConsiderationReadiness", + "namespace": "drefResponsePillar", + "value": "support for election readiness, civil unrest readiness and epidemic readiness when credible analysis indicates that the situation is likely to escalate." + }, + { + "action": "add", + "key": "faqCharConsiderationReadinessLink", + "namespace": "drefResponsePillar", + "value": "Readiness actions:" + }, + { + "action": "add", + "key": "faqCharConsiderations", + "namespace": "drefResponsePillar", + "value": "Specific Response DREF considerations:" + }, + { + "action": "add", + "key": "faqCharCost", + "namespace": "drefResponsePillar", + "value": "Cost considerations: a minimum reach of 100 households, or approximately 500 people, is recommended. The indicative cost per beneficiary is CHF 150, and the recommended budget ratio is 60 per cent for direct interventions and 40 per cent for support services. These recommendations do not apply to assessment-focused or epidemic operations where the cost structure may be different." + }, + { + "action": "add", + "key": "faqCharPlanning", + "namespace": "drefResponsePillar", + "value": "Planning and budget: the situation analysis, identified needs, operational strategy, activities, targets, indicators and budget must be consistent. Activities should be feasible for the National Society to deliver within the approved timeframe and should complement the response of authorities, Movement partners and other organisations." + }, + { + "action": "add", + "key": "faqCharThresholds", + "namespace": "drefResponsePillar", + "value": "Funding thresholds: up to CHF 500,000 for Yellow-level emergencies and up to CHF 1,000,000 for Orange-level emergencies. Red-level emergencies are normally addressed through an Emergency Appeal, although DREF Loan support may be considered for critical start-up activities." + }, + { + "action": "add", + "key": "faqCharTimeframe", + "namespace": "drefResponsePillar", + "value": "Operating timeframe: For standard Response DREF operations, up to six months for Yellow-level emergencies and up to nine months for Orange-level emergencies. Longer timeframes apply to the Drought DREF parameter when the operation includes anticipatory, response and early recovery activities." + }, + { + "action": "add", + "key": "faqCharTrigger", + "namespace": "drefResponsePillar", + "value": "Trigger mechanism: a clear trigger based on credible information about the occurrence, scale or worsening impact of an emergency. Triggers may include a sudden-onset disaster, a developing slow-onset crisis, verified impact data, government declarations, disease trends, displacement figures or other evidence of humanitarian need." + }, + { + "action": "add", + "key": "faqProcessImplementationCommunity", + "namespace": "drefResponsePillar", + "value": "maintaining community engagement and feedback mechanisms;" + }, + { + "action": "add", + "key": "faqProcessImplementationCoordinate", + "namespace": "drefResponsePillar", + "value": "coordinating with authorities, Movement partners and other actors;" + }, + { + "action": "add", + "key": "faqProcessImplementationDeliver", + "namespace": "drefResponsePillar", + "value": "delivering activities according to the approved plan;" + }, + { + "action": "add", + "key": "faqProcessImplementationFunds", + "namespace": "drefResponsePillar", + "value": "managing funds in line with the approved budget;" + }, + { + "action": "add", + "key": "faqProcessImplementationHeading", + "namespace": "drefResponsePillar", + "value": "Implementation, reporting and learning" + }, + { + "action": "add", + "key": "faqProcessImplementationIntro", + "namespace": "drefResponsePillar", + "value": "The National Society leads implementation and is responsible for:" + }, + { + "action": "add", + "key": "faqProcessImplementationMonitor", + "namespace": "drefResponsePillar", + "value": "monitoring activities, reach and expenditure;" + }, + { + "action": "add", + "key": "faqProcessImplementationOutro", + "namespace": "drefResponsePillar", + "value": "Implementation should remain responsive to changing needs, but any material change to the operational strategy, budget or timeframe must follow the applicable DREF revision and approval process." + }, + { + "action": "add", + "key": "faqProcessImplementationReporting", + "namespace": "drefResponsePillar", + "value": "completing the required final reporting and closure processes." + }, + { + "action": "add", + "key": "faqProcessImplementationUpdates", + "namespace": "drefResponsePillar", + "value": "submitting Operations Updates when changes or additional support are required; and" + }, + { + "action": "add", + "key": "faqProcessPlanningAdvance", + "namespace": "drefResponsePillar", + "value": "For a sudden-onset emergency requiring immediate liquidity, an Emergency Advance Payment may be requested within 24 hours while the full application is being prepared." + }, + { + "action": "add", + "key": "faqProcessPlanningAssessment", + "namespace": "drefResponsePillar", + "value": "determine whether further assessment is needed;" + }, + { + "action": "add", + "key": "faqProcessPlanningCapacity", + "namespace": "drefResponsePillar", + "value": "assess available National Society resources and capacity;" + }, + { + "action": "add", + "key": "faqProcessPlanningEligible", + "namespace": "drefResponsePillar", + "value": "confirm that the proposed activities are eligible, feasible and proportionate." + }, + { + "action": "add", + "key": "faqProcessPlanningGaps", + "namespace": "drefResponsePillar", + "value": "identify remaining humanitarian gaps;" + }, + { + "action": "add", + "key": "faqProcessPlanningHeading", + "namespace": "drefResponsePillar", + "value": "Planning and submission" + }, + { + "action": "add", + "key": "faqProcessPlanningIntro", + "namespace": "drefResponsePillar", + "value": "The Response DREF process begins when a National Society identifies a disaster or developing crisis and assesses whether external support is required." + }, + { + "action": "add", + "key": "faqProcessPlanningLink", + "namespace": "drefResponsePillar", + "value": "The application should link the situation analysis, identified needs, target population, planned activities and budget." + }, + { + "action": "add", + "key": "faqProcessPlanningOffline", + "namespace": "drefResponsePillar", + "value": "offline using the dedicated Excel template, which is then uploaded to GO." + }, + { + "action": "add", + "key": "faqProcessPlanningOnline", + "namespace": "drefResponsePillar", + "value": "online through the GO Platform using the DREF Application template; or" + }, + { + "action": "add", + "key": "faqProcessPlanningOption", + "namespace": "drefResponsePillar", + "value": "select the appropriate DREF option;" + }, + { + "action": "add", + "key": "faqProcessPlanningReview", + "namespace": "drefResponsePillar", + "value": "review government, Movement and partner response;" + }, + { + "action": "add", + "key": "faqProcessPlanningStrategy", + "namespace": "drefResponsePillar", + "value": "develop the operational strategy, indicators, workplan and budget; and" + }, + { + "action": "add", + "key": "faqProcessPlanningSubmitted", + "namespace": "drefResponsePillar", + "value": "The application can be prepared and submitted:" + }, + { + "action": "add", + "key": "faqProcessPlanningSupported", + "namespace": "drefResponsePillar", + "value": "The National Society, supported by the IFRC Delegation and relevant technical teams, should:" + }, + { + "action": "add", + "key": "faqProcessPlanningTiming", + "namespace": "drefResponsePillar", + "value": "Applications should be submitted as soon as possible, ideally within five days of the disaster or trigger date. Drought DREF requests must be submitted and approved within 21 days of the trigger." + }, + { + "action": "add", + "key": "faqProcessPlanningTrigger", + "namespace": "drefResponsePillar", + "value": "identify the trigger and analyse the humanitarian situation;" + }, + { + "action": "add", + "key": "faqProcessReviewAgreement", + "namespace": "drefResponsePillar", + "value": "the Project Agreement and payment process are completed." + }, + { + "action": "add", + "key": "faqProcessReviewAllocation", + "namespace": "drefResponsePillar", + "value": "the DREF Allocation Request is prepared;" + }, + { + "action": "add", + "key": "faqProcessReviewApproval", + "namespace": "drefResponsePillar", + "value": "the DREF Appeal Manager approves the application, budget and release of funds; and" + }, + { + "action": "add", + "key": "faqProcessReviewChecklist", + "namespace": "drefResponsePillar", + "value": "the Review Checklist is finalised;" + }, + { + "action": "add", + "key": "faqProcessReviewComments", + "namespace": "drefResponsePillar", + "value": "The National Society responds to comments and provides revisions or clarifications where required. For sudden-onset operations, the full Operational Quality Review should normally be completed within 10 days. For slow-onset operations, it should normally be completed within 21 days of the identified trigger." + }, + { + "action": "add", + "key": "faqProcessReviewCompleteIntro", + "namespace": "drefResponsePillar", + "value": "Once the reviews are complete:" + }, + { + "action": "add", + "key": "faqProcessReviewEligibilityBudget", + "namespace": "drefResponsePillar", + "value": "whether the budget contains eligible and non-duplicated costs; and" + }, + { + "action": "add", + "key": "faqProcessReviewEligibilityCompliance", + "namespace": "drefResponsePillar", + "value": "whether the National Society meets the required compliance standards;" + }, + { + "action": "add", + "key": "faqProcessReviewEligibilityHeading", + "namespace": "drefResponsePillar", + "value": "Eligibility, Compliance and Risk Management Review" + }, + { + "action": "add", + "key": "faqProcessReviewEligibilityIntro", + "namespace": "drefResponsePillar", + "value": "This mandatory review confirms:" + }, + { + "action": "add", + "key": "faqProcessReviewEligibilityRisks", + "namespace": "drefResponsePillar", + "value": "whether key operational, financial and delivery risks have been identified." + }, + { + "action": "add", + "key": "faqProcessReviewEligibilityRules", + "namespace": "drefResponsePillar", + "value": "whether the operation is eligible under DREF rules;" + }, + { + "action": "add", + "key": "faqProcessReviewEligibilityTiming", + "namespace": "drefResponsePillar", + "value": "This review should normally be completed within 24 hours of submission." + }, + { + "action": "add", + "key": "faqProcessReviewFinance", + "namespace": "drefResponsePillar", + "value": "Regional Finance validates the budget and confirms that the proposed costs are eligible and correctly classified." + }, + { + "action": "add", + "key": "faqProcessReviewHeading", + "namespace": "drefResponsePillar", + "value": "Review, approval and disbursement" + }, + { + "action": "add", + "key": "faqProcessReviewIntro", + "namespace": "drefResponsePillar", + "value": "Once the application is submitted, two reviews take place in parallel." + }, + { + "action": "add", + "key": "faqProcessReviewPackage", + "namespace": "drefResponsePillar", + "value": "the final package is submitted for approval;" + }, + { + "action": "add", + "key": "faqProcessReviewQualityCapacity", + "namespace": "drefResponsePillar", + "value": "the capacity of the National Society to deliver the operation." + }, + { + "action": "add", + "key": "faqProcessReviewQualityCoherence", + "namespace": "drefResponsePillar", + "value": "the coherence of the response strategy;" + }, + { + "action": "add", + "key": "faqProcessReviewQualityFeasibility", + "namespace": "drefResponsePillar", + "value": "the feasibility of implementation;" + }, + { + "action": "add", + "key": "faqProcessReviewQualityHeading", + "namespace": "drefResponsePillar", + "value": "Operational Quality Review" + }, + { + "action": "add", + "key": "faqProcessReviewQualityIntro", + "namespace": "drefResponsePillar", + "value": "The Operational Quality Review assesses:" + }, + { + "action": "add", + "key": "faqProcessReviewQualityMonitoring", + "namespace": "drefResponsePillar", + "value": "the monitoring and accountability arrangements; and" + }, + { + "action": "add", + "key": "faqProcessReviewQualityNeeds", + "namespace": "drefResponsePillar", + "value": "the strength of the needs analysis;" + }, + { + "action": "add", + "key": "faqProcessReviewQualityTargeting", + "namespace": "drefResponsePillar", + "value": "the appropriateness of the targeting;" + }, + { + "action": "add", + "key": "faqProcessReviewQualityTechnical", + "namespace": "drefResponsePillar", + "value": "the technical quality of the activities;" + }, + { + "action": "add", + "key": "faqResponseDrefParaOne", + "namespace": "drefResponsePillar", + "value": "The Response DREF provides rapid and flexible financial support to National Societies responding to small- and medium-scale emergencies. It can be used following a sudden-onset disaster or while a slow-onset crisis is developing, when the situation exceeds the National Society’s available capacity and requires additional humanitarian support." + }, + { + "action": "add", + "key": "faqResponseDrefParaThree", + "namespace": "drefResponsePillar", + "value": "The type of crisis, the available evidence and the likely scale of the response determine how the operation should be designed. Where the emergency is expected to require a broader international response, the DREF may be linked to an Emergency Appeal. In Red-level emergencies, a DREF Loan can provide bridge financing for critical start-up activities while donor contributions to the Appeal are being mobilised." + }, + { + "action": "add", + "key": "faqResponseDrefParaTwo", + "namespace": "drefResponsePillar", + "value": "The Response DREF is designed to support locally led, needs-based action. It may fund direct humanitarian assistance, an assessment to clarify the situation and inform a later response, or activities responding to a developing crisis such as drought, food insecurity, water shortages or disease outbreaks." + }, + { + "action": "add", + "key": "faqResponseDrefQuestion", + "namespace": "drefResponsePillar", + "value": "What is a Response DREF?" + }, + { + "action": "add", + "key": "faqResponseProcessQuestion", + "namespace": "drefResponsePillar", + "value": "Response DREF Process" + }, + { + "action": "add", + "key": "fullResponseGuidanceLink", + "namespace": "drefResponsePillar", + "value": "Full Response Pillar Guidance" + }, + { + "action": "add", + "key": "responseIntro", + "namespace": "drefResponsePillar", + "value": "The Response Pillar provides funding for small- and medium-scale emergencies, whether triggered by sudden-onset events or developing slow-onset crises. It includes Response DREF grants for locally led humanitarian action and DREF Loans, which provide bridge financing for large-scale Red-category emergencies linked to an Emergency Appeal. Response DREF is a flexible mechanism, but its design may need to be adapted to the context, available evidence and operational purpose. Specific considerations apply when it is used for drought, assessments or readiness actions in situations such as epidemics, civil unrest or elections." + }, + { + "action": "add", + "key": "eapMapLoginRequired", + "namespace": "eapMap", + "value": "Log in to view the map of approved EAPs." + }, + { + "action": "add", + "key": "eapMapTitle", + "namespace": "eapMap", + "value": "Approved EAPs" + }, + { + "action": "add", + "key": "eapMapType", + "namespace": "eapMap", + "value": "EAP type" + }, + { + "action": "add", + "key": "eapTableCountry", + "namespace": "eapTable", + "value": "Country" + }, + { + "action": "add", + "key": "eapTableDate", + "namespace": "eapTable", + "value": "Date of Approval / Activation" + }, + { + "action": "add", + "key": "eapTableDisasterType", + "namespace": "eapTable", + "value": "Disaster Type" + }, + { + "action": "add", + "key": "eapTableHeading", + "namespace": "eapTable", + "value": "Recent EAPs" + }, + { + "action": "add", + "key": "eapTableLoginRequired", + "namespace": "eapTable", + "value": "Log in to view recent EAPs." + }, + { + "action": "add", + "key": "eapTableName", + "namespace": "eapTable", + "value": "EAP Title" + }, + { + "action": "add", + "key": "eapTableRequirements", + "namespace": "eapTable", + "value": "Requirements (CHF)" + }, + { + "action": "add", + "key": "eapTableStatus", + "namespace": "eapTable", + "value": "EAP Status" + }, + { + "action": "remove", + "key": "eapContent", + "namespace": "earlyActionProtocols" + }, + { + "action": "remove", + "key": "eapContentHeading", + "namespace": "earlyActionProtocols" + }, + { + "action": "remove", + "key": "eapContentSubHeadingOne", + "namespace": "earlyActionProtocols" + }, + { + "action": "remove", + "key": "eapContentSubHeadingThree", + "namespace": "earlyActionProtocols" + }, + { + "action": "remove", + "key": "eapContentSubHeadingTwo", + "namespace": "earlyActionProtocols" + }, + { + "action": "remove", + "key": "eapDescriptionOne", + "namespace": "earlyActionProtocols" + }, + { + "action": "remove", + "key": "eapDescriptionThree", + "namespace": "earlyActionProtocols" + }, + { + "action": "remove", + "key": "eapDescriptionTwo", + "namespace": "earlyActionProtocols" + }, + { + "action": "remove", + "key": "eapRegistrationLink", + "namespace": "earlyActionProtocols" + }, + { + "action": "add", + "key": "imminentMapDisasterTypePlaceholder", + "namespace": "imminentDrefMap", + "value": "All Hazards" + }, + { + "action": "add", + "key": "imminentMapLegend", + "namespace": "imminentDrefMap", + "value": "Imminent DREF" + }, + { + "action": "add", + "key": "imminentMapLoginRequired", + "namespace": "imminentDrefMap", + "value": "Log in to view the map of imminent DREF operations." + }, + { + "action": "add", + "key": "imminentMapStatus", + "namespace": "imminentDrefMap", + "value": "Status" + }, + { + "action": "add", + "key": "imminentMapTitle", + "namespace": "imminentDrefMap", + "value": "Map of Imminent DREF operations" + }, + { + "action": "add", + "key": "imminentClearFilters", + "namespace": "imminentDrefTable", + "value": "Clear Filters" + }, + { + "action": "add", + "key": "imminentCode", + "namespace": "imminentDrefTable", + "value": "Appeal Code" + }, + { + "action": "add", + "key": "imminentCountry", + "namespace": "imminentDrefTable", + "value": "Country" + }, + { + "action": "add", + "key": "imminentDisasterType", + "namespace": "imminentDrefTable", + "value": "Disaster Type" + }, + { + "action": "add", + "key": "imminentFilterAllYears", + "namespace": "imminentDrefTable", + "value": "All Years" + }, + { + "action": "add", + "key": "imminentFilterSearchPlaceholder", + "namespace": "imminentDrefTable", + "value": "Search" + }, + { + "action": "add", + "key": "imminentLoginRequired", + "namespace": "imminentDrefTable", + "value": "Log in to view imminent DREF operations." + }, + { + "action": "add", + "key": "imminentOperation", + "namespace": "imminentDrefTable", + "value": "Operation" + }, + { + "action": "add", + "key": "imminentStartDate", + "namespace": "imminentDrefTable", + "value": "Start Date" + }, + { + "action": "add", + "key": "imminentTableHeading", + "namespace": "imminentDrefTable", + "value": "Imminent DREF operations" + } + ] +} \ No newline at end of file