@lysaab/lysa-pep 6.2.0 → 7.0.0

package/src/pages/RelationPage/RelationPage.tsx

@@ -0,0 +1,306 @@
+import React, {
+  useContext,
+  useRef,
+  useCallback,
+  FunctionComponent,
+} from "react";
+import {
+  PepContext,
+  PepType,
+  BusinessRelation,
+  Relation,
+  EntityType,
+  PepContextProps,
+} from "../PepContext";
+import {
+  LysaFormRef,
+  RadioGroup,
+  Form,
+  Alternative,
+  RequiredValidator,
+  TextInput,
+  Datepicker,
+  Button,
+  Card,
+} from "@lysaab/ui-2";
+import { DateTime } from "luxon";
+import { useIntl, IntlShape, FormattedMessage } from "react-intl";
+import {
+  relationMessages,
+  businessRelationMessages,
+  relativeNameMessages,
+  birthdayMessages,
+  colleagueNameMessages,
+} from "./RelationMessages";
+import { formatPossessive } from "../../utils/Possession";
+
+const DATEPICKER_START_DATE = DateTime.fromISO("1970-01-01").toJSDate();
+
+interface Props {
+  next: () => void;
+}
+
+export const RelationPage: FunctionComponent<Props> = ({ next }) => {
+  const intl = useIntl();
+  const pepContext = useContext(PepContext);
+  const formRef = useRef<LysaFormRef>();
+  const entityType = pepContext.state.legalEntityType || EntityType.PERSON;
+  const type = pepContext.state.type;
+
+  const businessRelationAlternatives = getBusinessRelationAlternatives(
+    intl,
+    entityType,
+    pepContext
+  );
+  const relationAlternatives = getRelationAlternatives(
+    intl,
+    entityType,
+    pepContext
+  );
+
+  const nextPage = useCallback(() => {
+    if (formRef.current && formRef.current.isValid) {
+      next();
+    }
+  }, [formRef, next]);
+  return (
+    <Form onSubmit={() => nextPage()} lysaFormRef={formRef}>
+      <Card>
+        {type === PepType.RELATIVE ? (
+          <RadioGroup
+            alternatives={relationAlternatives}
+            onChange={(alternative) => {
+              pepContext.setState({
+                relationToPEP: alternative.value,
+              });
+            }}
+            value={relationAlternatives.find(
+              (alt) => alt.value === pepContext.state.relationToPEP
+            )}
+            header={intl.formatMessage(relationMessages.header, {
+              entityType,
+              name: pepContext.state.ownerName,
+              possessiveName: formatPossessive(
+                pepContext.state.ownerName,
+                intl.locale
+              ),
+            })}
+            validators={[
+              new RequiredValidator(
+                intl.formatMessage(relationMessages.required)
+              ),
+            ]}
+          />
+        ) : null}
+        {type === PepType.COLLEAGUE ? (
+          <RadioGroup
+            alternatives={businessRelationAlternatives}
+            onChange={(alternative) => {
+              pepContext.setState({
+                businessRelation: alternative.value,
+              });
+            }}
+            value={businessRelationAlternatives.find(
+              (alt) => alt.value === pepContext.state.businessRelation
+            )}
+            header={intl.formatMessage(businessRelationMessages.header, {
+              entityType,
+              name: pepContext.state.ownerName,
+            })}
+            validators={[
+              new RequiredValidator(
+                intl.formatMessage(businessRelationMessages.required)
+              ),
+            ]}
+          />
+        ) : null}
+        {pepContext.state.relationToPEP && type === PepType.RELATIVE ? (
+          <React.Fragment>
+            <TextInput
+              label={intl.formatMessage(relativeNameMessages.header, {
+                entityType,
+                name: pepContext.state.ownerName,
+                relation:
+                  pepContext.state.type === PepType.COLLEAGUE
+                    ? pepContext.state.businessRelation
+                    : pepContext.state.relationToPEP,
+                possessiveName: formatPossessive(
+                  pepContext.state.ownerName,
+                  intl.locale
+                ),
+              })}
+              value={pepContext.state.nameOfPEP || ""}
+              onChange={(value) => {
+                pepContext.setState({ nameOfPEP: value });
+              }}
+              validators={[
+                new RequiredValidator(
+                  intl.formatMessage(relativeNameMessages.required)
+                ),
+              ]}
+            />
+            <Datepicker
+              label={intl.formatMessage(birthdayMessages.header, {
+                entityType,
+                name: pepContext.state.ownerName,
+                relation:
+                  pepContext.state.type === PepType.COLLEAGUE
+                    ? pepContext.state.businessRelation
+                    : pepContext.state.relationToPEP,
+                possessiveName: formatPossessive(
+                  pepContext.state.ownerName,
+                  intl.locale
+                ),
+              })}
+              selected={pepContext.state.birthdayOfPEP}
+              onChange={(event) => {
+                // event has a type that says it can be [startDate, endDate]
+                // but we know that will never be the case here
+                pepContext.setState({
+                  birthdayOfPEP: (event as Date) || undefined,
+                });
+              }}
+              validators={[
+                new RequiredValidator(
+                  intl.formatMessage(birthdayMessages.required)
+                ),
+              ]}
+              maxDate={new Date()}
+              openToDate={
+                pepContext.state.birthdayOfPEP || DATEPICKER_START_DATE
+              }
+            />
+          </React.Fragment>
+        ) : null}
+
+        {pepContext.state.businessRelation && type === PepType.COLLEAGUE ? (
+          <React.Fragment>
+            <TextInput
+              label={intl.formatMessage(colleagueNameMessages.header, {
+                entityType,
+                name: pepContext.state.ownerName,
+                relation:
+                  pepContext.state.type === PepType.COLLEAGUE
+                    ? pepContext.state.businessRelation
+                    : pepContext.state.relationToPEP,
+                possessiveName: formatPossessive(
+                  pepContext.state.ownerName,
+                  intl.locale
+                ),
+              })}
+              value={pepContext.state.nameOfPEP || ""}
+              onChange={(value) => {
+                pepContext.setState({ nameOfPEP: value });
+              }}
+              validators={[
+                new RequiredValidator(
+                  intl.formatMessage(colleagueNameMessages.required)
+                ),
+              ]}
+            />
+          </React.Fragment>
+        ) : null}
+      </Card>
+      <Button
+        block
+        type="submit"
+        label={<FormattedMessage id="pep.relation.next" />}
+      />
+    </Form>
+  );
+};
+function getRelationAlternatives(
+  intl: IntlShape,
+  entityType: EntityType,
+  pepContext: PepContextProps
+): Alternative<Relation>[] {
+  return [
+    {
+      text: intl.formatMessage(relationMessages[Relation.MARRIED_PARTNER], {
+        entityType,
+        name: pepContext.state.ownerName,
+      }),
+      value: Relation.MARRIED_PARTNER,
+    },
+    {
+      text: intl.formatMessage(relationMessages[Relation.COLIVING_PARTNER], {
+        entityType,
+        name: pepContext.state.ownerName,
+      }),
+      value: Relation.COLIVING_PARTNER,
+    },
+    {
+      text: intl.formatMessage(relationMessages[Relation.CHILD], {
+        entityType,
+        name: pepContext.state.ownerName,
+      }),
+      value: Relation.CHILD,
+    },
+    {
+      text: intl.formatMessage(relationMessages[Relation.PARENT], {
+        entityType,
+        name: pepContext.state.ownerName,
+      }),
+      value: Relation.PARENT,
+    },
+    {
+      text: intl.formatMessage(
+        relationMessages[Relation.CHILD_MARRIED_PARTNER],
+        {
+          entityType,
+          name: pepContext.state.ownerName,
+        }
+      ),
+      value: Relation.CHILD_MARRIED_PARTNER,
+    },
+    {
+      text: intl.formatMessage(
+        relationMessages[Relation.CHILD_COLIVING_PARTNER],
+        {
+          entityType,
+          name: pepContext.state.ownerName,
+        }
+      ),
+      value: Relation.CHILD_COLIVING_PARTNER,
+    },
+  ];
+}
+
+function getBusinessRelationAlternatives(
+  intl: IntlShape,
+  entityType: EntityType,
+  pepContext: PepContextProps
+): Alternative<BusinessRelation>[] {
+  return [
+    {
+      text: intl.formatMessage(
+        businessRelationMessages[BusinessRelation.CO_OWNERSHIP],
+        {
+          entityType,
+          name: pepContext.state.ownerName,
+        }
+      ),
+      value: BusinessRelation.CO_OWNERSHIP,
+    },
+    {
+      text: intl.formatMessage(
+        businessRelationMessages[BusinessRelation.CLOSE_CONNECTION],
+        {
+          entityType,
+          name: pepContext.state.ownerName,
+        }
+      ),
+      value: BusinessRelation.CLOSE_CONNECTION,
+    },
+    {
+      text: intl.formatMessage(
+        businessRelationMessages[BusinessRelation.COMPANY_FOR_PEP],
+        {
+          entityType,
+          name: pepContext.state.ownerName,
+        }
+      ),
+      value: BusinessRelation.COMPANY_FOR_PEP,
+    },
+  ];
+}

package/src/pages/RolePage/RoleMessages.ts

@@ -0,0 +1,128 @@
+import { defineMessages } from "react-intl";
+import { Role, MilitaryRank } from "../PepContext";
+
+export const roleMessages = defineMessages({
+  header: {
+    id: "pep.role.roles.header",
+  },
+  placeholder: {
+    id: "pep.role.roles.placeholder",
+  },
+  required: {
+    id: "pep.role.roles.required",
+  },
+  [Role.HEAD_OF_GOVERNMENT]: {
+    id: "pep.role.roles.alt.HEAD_OF_GOVERNMENT",
+  },
+  [Role.MINISTER]: {
+    id: "pep.role.roles.alt.MINISTER",
+  },
+  [Role.PARLIMENT_MEMBER]: {
+    id: "pep.role.roles.alt.PARLIMENT_MEMBER",
+  },
+  [Role.CENTRAL_BANK_MEMBER]: {
+    id: "pep.role.roles.alt.CENTRAL_BANK_MEMBER",
+  },
+  [Role.BOARD_MEMBER_POLITICAL_PARTY]: {
+    id: "pep.role.roles.alt.BOARD_MEMBER_POLITICAL_PARTY",
+  },
+  [Role.JUDGE_SUPREME_COURT]: {
+    id: "pep.role.roles.alt.JUDGE_SUPREME_COURT",
+  },
+  [Role.JUDGE_OTHER_HIGH_COURT]: {
+    id: "pep.role.roles.alt.JUDGE_OTHER_HIGH_COURT",
+  },
+  [Role.REVISION_INSTITUTE]: {
+    id: "pep.role.roles.alt.REVISION_INSTITUTE",
+  },
+  [Role.AMBASSADOR]: {
+    id: "pep.role.roles.alt.AMBASSADOR",
+  },
+  [Role.MILITARY_OFFICER]: {
+    id: "pep.role.roles.alt.MILITARY_OFFICER",
+  },
+  [Role.GOVERNMENT_COMPANY]: {
+    id: "pep.role.roles.alt.GOVERNMENT_COMPANY",
+  },
+  [Role.EU_HIGH_RANKING_POSITION]: {
+    id: "pep.role.roles.alt.EU_HIGH_RANKING_POSITION",
+  },
+  [Role.HIGH_RANKING_POSITION_INTERNALTIONAL_CORP]: {
+    id: "pep.role.roles.alt.HIGH_RANKING_POSITION_INTERNALTIONAL_CORP",
+  },
+});
+
+export const militaryMessages = defineMessages({
+  header: {
+    id: "pep.role.military.name.header",
+  },
+  placeholder: {
+    id: "pep.role.military.header",
+  },
+  required: {
+    id: "pep.role.military.required",
+  },
+  [MilitaryRank.GENERAL]: {
+    id: "pep.role.military.alt.GENERAL",
+  },
+  [MilitaryRank.LIEUTENANT_GENERAL]: {
+    id: "pep.role.military.alt.LIEUTENANT_GENERAL",
+  },
+  [MilitaryRank.MAJOR_GENERAL]: {
+    id: "pep.role.military.alt.MAJOR_GENERAL",
+  },
+  [MilitaryRank.ADMIRAL]: {
+    id: "pep.role.military.alt.ADMIRAL",
+  },
+  [MilitaryRank.VICE_ADMIRAL]: {
+    id: "pep.role.military.alt.VICE_ADMIRAL",
+  },
+  [MilitaryRank.REAR_ADMIRAL]: {
+    id: "pep.role.military.alt.REAR_ADMIRAL",
+  },
+});
+
+export const ambassadorMessages = defineMessages({
+  header: {
+    id: "pep.role.ambassador.header",
+  },
+  required: {
+    id: "pep.role.ambassador.required",
+  },
+  placeholder: {
+    id: "pep.role.ambassador.placeholder",
+  },
+});
+
+export const governmentCompanyMessages = defineMessages({
+  nameHeader: {
+    id: "pep.role.governmentCompany.name.header",
+  },
+  nameRequired: {
+    id: "pep.role.governmentCompany.name.required",
+  },
+  roleHeader: {
+    id: "pep.role.governmentCompany.role.header",
+  },
+  roleRequired: {
+    id: "pep.role.governmentCompany.role.required",
+  },
+});
+
+export const intCompanyMessages = defineMessages({
+  nameHeader: {
+    id: "pep.role.intCompany.name.header",
+  },
+  nameRequired: {
+    id: "pep.role.intCompany.name.required",
+  },
+  roleHeader: {
+    id: "pep.role.intCompany.role.header",
+  },
+  roleRequired: {
+    id: "pep.role.intCompany.role.required",
+  },
+});
+
+export const countrySelectionMessages = defineMessages({
+});