8652005424

Committed 11 Apr 2024 07:10PM UTC coverage: 97.361% (-0.1%) from 97.459%

Build # 8652005424

Build Type

Pull #369

github

Committed by

GermanSaracca

Commit Message

feat: Bring back error validation alert and add tests

Pull Request Pull Request #369: Feature/sub branch/dynamic fields and validation

Run Details

692 of 725 branches covered (95.45%)

Branch coverage included in aggregate %.

217 of 219 new or added lines in 28 files covered. (99.09%)

1 existing line in 1 file now uncovered.

1854 of 1890 relevant lines covered (98.1%)

3653.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.3

/src/sections/create-dataset/MetadataBlockFormFields/MetadataFormField/index.tsx

import { useMemo } from 'react'
import { Controller, useFormContext } from 'react-hook-form'
import { Col, Form, Row } from '@iqss/dataverse-design-system'
import { useDefineRules } from './useDefineRules'
import {
  MetadataField,
  TypeClassMetadataFieldOptions,
  TypeMetadataFieldOptions
} from '../../../../metadata-block-info/domain/models/MetadataBlockInfo'
import {
  DateField,
  EmailField,
  FloatField,
  IntField,
  TextBoxField,
  TextField,
  UrlField,
  Vocabulary,
  VocabularyMultiple
} from './Fields'
import styles from './index.module.scss'

interface Props {
  metadataFieldInfo: MetadataField
  metadataBlockName: string
  withinMultipleFieldsGroup?: boolean
  compoundParentName?: string
}

export const MetadataFormField = ({
  metadataFieldInfo,
  metadataBlockName,
  withinMultipleFieldsGroup = false,
  compoundParentName
}: Props) => {
  const {
    name,
    type,
    title,
    displayName,
    multiple,
    typeClass,
    isRequired,
    description,
    watermark,
    childMetadataFields,
    controlledVocabularyValues
  } = metadataFieldInfo

  const { control } = useFormContext()

  const rulesToApply = useDefineRules({ metadataFieldInfo })

  // Field Name is built by the metadataBlockName (e.g. 'citation') and the metadataField name (e.g. title), and if compound parent name is present, it will be added to the name also
  // e.g. citation.title or citation.author.authorName
  const builtFieldName = useMemo(
    () =>
      compoundParentName
        ? `${metadataBlockName}.${compoundParentName}.${name}`
        : `${metadataBlockName}.${name}`,
    [metadataBlockName, compoundParentName, name]
  )

  const isSafeCompound =
    typeClass === TypeClassMetadataFieldOptions.Compound &&
    childMetadataFields !== undefined &&
    Object.keys(childMetadataFields).length > 0

  const isSafeControlledVocabulary =
    typeClass === TypeClassMetadataFieldOptions.ControlledVocabulary &&
    controlledVocabularyValues !== undefined &&
    controlledVocabularyValues.length > 0

  const isSafePrimitive = typeClass === TypeClassMetadataFieldOptions.Primitive

  if (isSafeCompound) {
    return (
      <Form.GroupWithMultipleFields
        title={title}
        message={description}
        required={isRequired}
        withDynamicFields={false}>
        <div className={styles['multiple-fields-grid']}>
          {Object.entries(childMetadataFields).map(
            ([childMetadataFieldKey, childMetadataFieldInfo]) => {
              return (
                <MetadataFormField
                  metadataFieldInfo={childMetadataFieldInfo}
                  metadataBlockName={metadataBlockName}
                  compoundParentName={name}
                  withinMultipleFieldsGroup
                  key={childMetadataFieldKey}
                />
              )
            }
          )}
        </div>
      </Form.GroupWithMultipleFields>
    )
  }

  if (isSafeControlledVocabulary) {
    if (multiple) {
      return (
        <VocabularyMultiple
          title={title}
          name={builtFieldName}
          displayName={displayName}
          description={description}
          options={controlledVocabularyValues}
          isRequired={isRequired}
          control={control}
        />
      )
    }
    return (
      <Controller
        name={builtFieldName}
        control={control}
        rules={rulesToApply}
        render={({ field: { onChange, ref }, fieldState: { invalid, error } }) => (
          <Form.Group
            controlId={name}
            required={isRequired}
            as={withinMultipleFieldsGroup ? Col : Row}>
            <Form.Group.Label message={description}>{title}</Form.Group.Label>
            <Vocabulary
              onChange={onChange}
              isInvalid={invalid}
              options={controlledVocabularyValues}
              ref={ref}
            />
            <Form.Group.Feedback type="invalid">{error?.message}</Form.Group.Feedback>
          </Form.Group>
        )}
      />
    )
  }

  if (isSafePrimitive) {
    return (
      <Controller
        name={builtFieldName}
        control={control}
        rules={rulesToApply}
        render={({ field: { onChange, ref }, fieldState: { invalid, error } }) => (
          <Form.Group
            controlId={name}
            required={isRequired}
            as={withinMultipleFieldsGroup ? Col : undefined}>
            <Form.Group.Label message={description}>{title}</Form.Group.Label>

            <>
              {type === TypeMetadataFieldOptions.Text && (
                <TextField
                  onChange={onChange}
                  isInvalid={invalid}
                  placeholder={watermark}
                  ref={ref}
                />
              )}
              {type === TypeMetadataFieldOptions.Textbox && (
                <TextBoxField
                  onChange={onChange}
                  isInvalid={invalid}
                  placeholder={watermark}
                  ref={ref}
                />
              )}
              {type === TypeMetadataFieldOptions.URL && (
                <UrlField
                  onChange={onChange}
                  isInvalid={invalid}
                  placeholder={watermark}
                  ref={ref}
                />
              )}
              {type === TypeMetadataFieldOptions.Email && (
                <EmailField
                  onChange={onChange}
                  isInvalid={invalid}
                  placeholder={watermark}
                  ref={ref}
                />
              )}
              {type === TypeMetadataFieldOptions.Int && (
                <IntField
                  onChange={onChange}
                  isInvalid={invalid}
                  placeholder={watermark}
                  ref={ref}
                />
              )}
              {type === TypeMetadataFieldOptions.Float && (
                <FloatField
                  onChange={onChange}
                  isInvalid={invalid}
                  placeholder={watermark}
                  ref={ref}
                />
              )}
              {type === TypeMetadataFieldOptions.Date && (
                <DateField
                  onChange={onChange}
                  isInvalid={invalid}
                  placeholder={watermark}
                  ref={ref}
                />
              )}
            </>

            <Form.Group.Feedback type="invalid">{error?.message}</Form.Group.Feedback>
          </Form.Group>
        )}
      />
    )
  }

  return null
}

1	import { useMemo } from 'react'
2	import { Controller, useFormContext } from 'react-hook-form'
3	import { Col, Form, Row } from '@iqss/dataverse-design-system'
4	import { useDefineRules } from './useDefineRules'
5	import {
6	MetadataField,
7	TypeClassMetadataFieldOptions,
8	TypeMetadataFieldOptions
9	} from '../../../../metadata-block-info/domain/models/MetadataBlockInfo'
10	import {
11	DateField,
12	EmailField,
13	FloatField,
14	IntField,
15	TextBoxField,
16	TextField,
17	UrlField,
18	Vocabulary,
19	VocabularyMultiple
20	} from './Fields'
21	import styles from './index.module.scss'
22
23	interface Props {
24	metadataFieldInfo: MetadataField
25	metadataBlockName: string
26	withinMultipleFieldsGroup?: boolean
27	compoundParentName?: string
28	}
29
30	export const MetadataFormField = ({	13✔
31	metadataFieldInfo,
32	metadataBlockName,
33	withinMultipleFieldsGroup = false,	9,520✔
34	compoundParentName
35	}: Props) => {	17,920✔
36	const {
37	name,
38	type,
39	title,
40	displayName,
41	multiple,
42	typeClass,
43	isRequired,
44	description,
45	watermark,
46	childMetadataFields,
47	controlledVocabularyValues
48	} = metadataFieldInfo	17,920✔
49
50	const { control } = useFormContext()	17,920✔
51
52	const rulesToApply = useDefineRules({ metadataFieldInfo })	17,920✔
53
54	// Field Name is built by the metadataBlockName (e.g. 'citation') and the metadataField name (e.g. title), and if compound parent name is present, it will be added to the name also
55	// e.g. citation.title or citation.author.authorName
56	const builtFieldName = useMemo(	17,920✔
57	() =>
58	compoundParentName	5,376✔
59	? `${metadataBlockName}.${compoundParentName}.${name}`
60	: `${metadataBlockName}.${name}`,
61	[metadataBlockName, compoundParentName, name]
62	)
63
64	const isSafeCompound =
65	typeClass === TypeClassMetadataFieldOptions.Compound &&	17,920✔
66	childMetadataFields !== undefined &&
67	Object.keys(childMetadataFields).length > 0
68
69	const isSafeControlledVocabulary =
70	typeClass === TypeClassMetadataFieldOptions.ControlledVocabulary &&	17,920✔
71	controlledVocabularyValues !== undefined &&
72	controlledVocabularyValues.length > 0
73
74	const isSafePrimitive = typeClass === TypeClassMetadataFieldOptions.Primitive	17,920✔
75
76	if (isSafeCompound) {	17,920✔
77	return (	2,800✔
78	<Form.GroupWithMultipleFields
79	title={title}
80	message={description}
81	required={isRequired}
82	withDynamicFields={false}>
83	<div className={styles['multiple-fields-grid']}>
84	{Object.entries(childMetadataFields).map(
85	([childMetadataFieldKey, childMetadataFieldInfo]) => {
86	return (	8,400✔
87	<MetadataFormField
88	metadataFieldInfo={childMetadataFieldInfo}
89	metadataBlockName={metadataBlockName}
90	compoundParentName={name}
91	withinMultipleFieldsGroup
92	key={childMetadataFieldKey}
93	/>
94	)
95	}
96	)}
97	</div>
98	</Form.GroupWithMultipleFields>
99	)
100	}
101
102	if (isSafeControlledVocabulary) {	15,120✔
103	if (multiple) {	1,120✔
104	return (	840✔
105	<VocabularyMultiple
106	title={title}
107	name={builtFieldName}
108	displayName={displayName}
109	description={description}
110	options={controlledVocabularyValues}
111	isRequired={isRequired}
112	control={control}
113	/>
114	)
115	}
116	return (	280✔
117	<Controller
118	name={builtFieldName}
119	control={control}
120	rules={rulesToApply}
121	render={({ field: { onChange, ref }, fieldState: { invalid, error } }) => (
122	<Form.Group	280✔
123	controlId={name}
124	required={isRequired}
125	as={withinMultipleFieldsGroup ? Col : Row}>	280!
126	<Form.Group.Label message={description}>{title}</Form.Group.Label>
127	<Vocabulary
128	onChange={onChange}
129	isInvalid={invalid}
130	options={controlledVocabularyValues}
131	ref={ref}
132	/>
133	<Form.Group.Feedback type="invalid">{error?.message}</Form.Group.Feedback>
134	</Form.Group>
135	)}
136	/>
137	)
138	}
139
140	if (isSafePrimitive) {	14,000✔
141	return (	14,000✔
142	<Controller
143	name={builtFieldName}
144	control={control}
145	rules={rulesToApply}
146	render={({ field: { onChange, ref }, fieldState: { invalid, error } }) => (
147	<Form.Group	16,193✔
148	controlId={name}
149	required={isRequired}
150	as={withinMultipleFieldsGroup ? Col : undefined}>	16,193✔
151	<Form.Group.Label message={description}>{title}</Form.Group.Label>
152
153	<>
154	{type === TypeMetadataFieldOptions.Text && (	24,969✔
155	<TextField
156	onChange={onChange}
157	isInvalid={invalid}
158	placeholder={watermark}
159	ref={ref}
160	/>
161	)}
162	{type === TypeMetadataFieldOptions.Textbox && (	17,131✔
163	<TextBoxField
164	onChange={onChange}
165	isInvalid={invalid}
166	placeholder={watermark}
167	ref={ref}
168	/>
169	)}
170	{type === TypeMetadataFieldOptions.URL && (	18,105✔
171	<UrlField
172	onChange={onChange}
173	isInvalid={invalid}
174	placeholder={watermark}
175	ref={ref}
176	/>
177	)}
178	{type === TypeMetadataFieldOptions.Email && (	16,830✔
179	<EmailField
180	onChange={onChange}
181	isInvalid={invalid}
182	placeholder={watermark}
183	ref={ref}
184	/>
185	)}
186	{type === TypeMetadataFieldOptions.Int && (	16,519✔
187	<IntField
188	onChange={onChange}
189	isInvalid={invalid}
190	placeholder={watermark}
191	ref={ref}
192	/>
193	)}
194	{type === TypeMetadataFieldOptions.Float && (	18,807✔
195	<FloatField
196	onChange={onChange}
197	isInvalid={invalid}
198	placeholder={watermark}
199	ref={ref}
200	/>
201	)}
202	{type === TypeMetadataFieldOptions.Date && (	17,183✔
203	<DateField
204	onChange={onChange}
205	isInvalid={invalid}
206	placeholder={watermark}
207	ref={ref}
208	/>
209	)}
210	</>
211
212	<Form.Group.Feedback type="invalid">{error?.message}</Form.Group.Feedback>
213	</Form.Group>
214	)}
215	/>
216	)
217	}
218
NEW 219	return null	×
220	}	13✔

IQSS / dataverse-frontend / 8652005424

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous