DomainFieldRow.java

package org.labkey.test.components.domain;

import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.Nullable;
import org.junit.Assert;
import org.labkey.api.exp.query.ExpSchema;
import org.labkey.test.BootstrapLocators;
import org.labkey.test.Locator;
import org.labkey.test.WebDriverWrapper;
import org.labkey.test.components.WebDriverComponent;
import org.labkey.test.components.bootstrap.ModalDialog;
import org.labkey.test.components.html.Checkbox;
import org.labkey.test.components.html.Input;
import org.labkey.test.components.html.RadioButton;
import org.labkey.test.components.html.SelectWrapper;
import org.labkey.test.components.react.FilteringReactSelect;
import org.labkey.test.components.ui.ontology.ConceptPickerDialog;
import org.labkey.test.pages.core.admin.BaseSettingsPage.DATE_FORMAT;
import org.labkey.test.pages.core.admin.BaseSettingsPage.TIME_FORMAT;
import org.labkey.test.params.FieldDefinition;
import org.labkey.test.util.LabKeyExpectedConditions;
import org.labkey.test.util.selenium.WebElementUtils;
import org.openqa.selenium.ElementNotInteractableException;
import org.openqa.selenium.NoSuchElementException;
import org.openqa.selenium.SearchContext;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.FluentWait;
import org.openqa.selenium.support.ui.Select;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import static org.junit.Assert.assertTrue;
import static org.labkey.test.WebDriverWrapper.WAIT_FOR_JAVASCRIPT;
import static org.labkey.test.WebDriverWrapper.waitFor;

public class DomainFieldRow extends WebDriverComponent<DomainFieldRow.ElementCache>
{
    public static final String ALL_SAMPLES_OPTION_TEXT = "All Samples";
    final WebElement _el;
    final WebDriver _driver;
    final DomainFormPanel _formPanel;

    public DomainFieldRow(DomainFormPanel panel, WebElement element, WebDriver driver)
    {
        _el = element;
        _driver = driver;
        _formPanel = panel;
    }

    @Override
    public WebElement getComponentElement()
    {
        return _el;
    }

    @Override
    public WebDriver getDriver()
    {
        return _driver;
    }

    // basic field properties

    public String getName()
    {
        return elementCache().fieldNameInput.getValue();
    }

    public DomainFieldRow setName(String name)
    {
        elementCache().fieldNameInput.setValue(name);
        return this;
    }

    public Input nameInput()
    {
        return elementCache().fieldNameInput;
    }

    public WebElement typeInput()
    {
        return elementCache().fieldTypeSelectInput.getWrappedElement();
    }

    public FieldDefinition.ColumnType getType()
    {
        // The previous code doesn't work:
        //  String typeString = getWrapper().getFormElement(elementCache().fieldTypeSelectInput);
        //  return Enum.valueOf(FieldDefinition.ColumnType.class, typeString);
        // getFormElement get's the value attribute which is not the same as the text shown and not the
        // same as the Enum.valueOf. To get a match get the text shown in the control and compare it
        // to the enum's label attribute.

        String typeString = getWrapper().getSelectedOptionText(elementCache().fieldTypeSelectInput.getWrappedElement());
        for (FieldDefinition.ColumnType ct : FieldDefinition.ColumnType.values())
        {
            if (ct.getLabel().equalsIgnoreCase(typeString))
                return ct;
        }
        throw new IllegalStateException("Unknown column type: " + typeString);
    }

    public List<String> getTypeOptions()
    {
        List<String> typeOptions = new ArrayList<>();
        for (WebElement option : elementCache().fieldTypeSelectInput.getOptions())
        {
            typeOptions.add(option.getText());
        }
        return typeOptions;
    }

    /**
     * Selects the field data type.
     */
    public DomainFieldRow setType(FieldDefinition.ColumnType columnType)
    {
        return setType(columnType, false);
    }

    /**
     * Selects the field data type.
     * @param confirmDialogExpected boolean indicating if this field data type change expects a confirm dialog
     */
    public DomainFieldRow setType(FieldDefinition.ColumnType columnType, boolean confirmDialogExpected)
    {
        elementCache().fieldTypeSelectInput.selectByVisibleText(columnType.getLabel());

        if (confirmDialogExpected)
        {
            ModalDialog confirmDialog = new ModalDialog.ModalDialogFinder(getDriver())
                    .withTitle("Confirm Data Type Change").timeout(1000).waitFor();
            confirmDialog.dismiss("Yes, Change Data Type");
        }

        return this;
    }

    /**
     * Selects the field data type and returns the 'are you sure' dialog.
     */
    public ModalDialog setTypeWithDialog(FieldDefinition.ColumnType columnType)
    {
        elementCache().fieldTypeSelectInput.selectByVisibleText(columnType.getLabel());
        return new ModalDialog.ModalDialogFinder(getDriver())
                .withTitle("Confirm Data Type Change").timeout(1000).waitFor();
    }

    public boolean getRequiredField()
    {
        return elementCache().fieldRequiredCheckbox.get();
    }

    public DomainFieldRow setRequiredField(boolean checked)
    {
        elementCache().fieldRequiredCheckbox.set(checked);
        return this;
    }

    public boolean hasRequiredField()
    {
        return elementCache().fieldRequiredCheckbox.isDisplayed();
    }

    public DomainFieldRow setSelectRowField(boolean checked)
    {
        elementCache().fieldSelectCheckbox.set(checked);
        return this;
    }

    public String detailsMessage()
    {
        return elementCache().fieldDetailsMessage.getText().trim();
    }

    public int getIndex()
    {
        String itemIndexAttribute = getComponentElement().getAttribute("tabindex");
        return Integer.parseInt(itemIndexAttribute);
    }

    public boolean isExpanded()
    {
        return elementCache().collapseToggleLoc.existsIn(this);
    }

    /**
     * Remove the field from the domain designer.
     *
     * @param confirmDialogExpected boolean indicating if this field removal expects a confirm dialog
     */
    public void clickRemoveField(boolean confirmDialogExpected)
    {
        getWrapper().mouseOver(elementCache().removeField);
        elementCache().removeField.click();

        if (confirmDialogExpected)
        {
            ModalDialog confirmDialog = new ModalDialog.ModalDialogFinder(getDriver())
                    .withTitle("Confirm Remove Field").timeout(1000).waitFor();
            confirmDialog.dismiss("Yes, Remove Field");
        }
    }

    public boolean isRemoveFieldBtnPresent()
    {
        return elementCache().removeFieldLoc.existsIn(this);
    }

    public DomainFieldRow setAdvancedSettings(List<AdvancedFieldSetting> settings)
    {
        if (!settings.isEmpty())
        {
            AdvancedSettingsDialog advancedSettingsDialog = clickAdvancedSettings();
            for (AdvancedFieldSetting setting : settings)
            {
                setting.accept(advancedSettingsDialog);
            }
            advancedSettingsDialog.apply();
        }
        return this;
    }

    public AdvancedSettingsDialog clickAdvancedSettings()
    {
        expand();
        WebDriverWrapper.waitFor(() -> elementCache().advancedSettingsBtn.isEnabled(),
                "the Advanced Settings button did not become enabled", 5000);
        int trycount = 0;
        do
        {
            getWrapper().log("clicking advanced settings button try=[" + trycount + "]");
            elementCache().advancedSettingsBtn.click();
            getWrapper().shortWait().until(LabKeyExpectedConditions.animationIsDone(getComponentElement()));
            trycount++;
            assertTrue("advanced settings dialog did not appear in time", trycount < 4);
        }
        while (!Locator.tagWithClass("div", "modal-backdrop").existsIn(getDriver()));

        return new AdvancedSettingsDialog(this);
    }

    public DomainFieldRow expand()
    {
        if (!isExpanded())
        {
            getWrapper().shortWait().until(ExpectedConditions.elementToBeClickable(elementCache().expandToggle));

            for (int i = 0; i < 3; i++)
            {
                elementCache().expandToggle.click();
                getWrapper().shortWait().until(LabKeyExpectedConditions.animationIsDone(getComponentElement())); // wait for transition to happen
                if (WebDriverWrapper.waitFor(this::isExpanded, 1000))
                    break;
            }
            WebDriverWrapper.waitFor(this::isExpanded,
                    "the field row did not become expanded", 1500);
        }
        return this;
    }

    public DomainFieldRow collapse()
    {
        if (isExpanded())
        {
            elementCache().collapseToggle.click();
            getWrapper().shortWait().until(LabKeyExpectedConditions.animationIsDone(getComponentElement())); // wait for transition to happen
            WebDriverWrapper.waitFor(() -> elementCache().expandToggleLoc.existsIn(this),
                    "the field row did not collapse", 1500);
        }
        return this;
    }

    /**
     * indicates that the field has been added, the user will need to save changes to persist.
     * New fields can have their type changed
     */
    public boolean isNewField()
    {
        return Locator.tagWithAttributeContaining("span", "id", "domainpropertiesrow-details")
                .withText("New Field").existsIn(this);
    }

    /**
     * indicates that the field has been edited (but is not new). The user will need to save changes to persist
     */
    public boolean isEditedField()
    {
        return Locator.tagWithAttributeContaining("span", "id", "domainpropertiesrow-details")
                .withText("Updated").existsIn(this);
    }

    //
    // common field options

    public String getDescription()
    {
        expand();
        return getWrapper().getFormElement(elementCache().descriptionTextArea);
    }

    public DomainFieldRow setDescription(String description)
    {
        expand();
        getWrapper().shortWait().until(ExpectedConditions.elementToBeClickable(elementCache().descriptionTextArea));
        try
        {
            getWrapper().setFormElement(elementCache().descriptionTextArea, description);
        }
        catch (ElementNotInteractableException retry)
        {
            WebDriverWrapper.sleep(500);
            getWrapper().setFormElement(elementCache().descriptionTextArea, description);
        }
        return this;
    }

    public String getAttachmentBehavior()
    {
        expand();
        return elementCache().attachmentBehavior.getFirstSelectedOption().getText();
    }

    public DomainFieldRow setAttachmentBehavior(String value)
    {
        expand();
        elementCache().attachmentBehavior.selectByVisibleText(value);
        return this;
    }

    public String getLabel()
    {
        expand();
        return elementCache().labelInput.getValue();
    }

    public DomainFieldRow setLabel(String label)
    {
        expand();
        elementCache().labelInput.setValue(label);
        return this;
    }

    public String getImportAliases()
    {
        expand();
        return elementCache().importAliasesInput.getValue();
    }

    public DomainFieldRow setImportAliases(String aliases)
    {
        expand();
        elementCache().importAliasesInput.setValue(aliases);
        return this;
    }

    public String getUrl()
    {
        expand();
        return elementCache().urlInput.getValue();
    }

    public DomainFieldRow setUrl(String url)
    {
        expand();
        elementCache().urlInput.setValue(url);
        return this;
    }

    public boolean isUrlOpenNewTab()
    {
        expand();
        return elementCache().urlTargetCheckbox.get();
    }

    public DomainFieldRow setUrlOpenNewTab(boolean checked)
    {
        expand();
        elementCache().urlTargetCheckbox.set(checked);
        return this;
    }

    //
    // numeric field options.

    public String getNumberFormat()
    {
        return getFormat();
    }

    public DomainFieldRow setNumberFormat(String formatString)
    {
        return setFormat(formatString);
    }

    public FieldDefinition.ScaleType getScaleType()
    {
        expand();
        String scaleTypeString = getWrapper().getFormElement(elementCache().defaultScaleTypeSelect.getWrappedElement());
        return Enum.valueOf(FieldDefinition.ScaleType.class, scaleTypeString.toUpperCase());
    }

    public DomainFieldRow setScaleType(FieldDefinition.ScaleType scaleType)
    {
        expand();
        elementCache().defaultScaleTypeSelect.selectByVisibleText(scaleType.getText());
        return this;
    }

    // generic set format.
    public DomainFieldRow setFormat(String formatString)
    {
        return setFormat(formatString, null);
    }

    public DomainFieldRow setFormat(String formatString, @Nullable String dataType)
    {
        expand();


        if (FieldDefinition.ColumnType.DateAndTime.getRangeURI().equals(dataType) ||
                FieldDefinition.ColumnType.Date.getRangeURI().equals(dataType) ||
                (FieldDefinition.ColumnType.Time.getRangeURI().equals(dataType)))
        {
            throw new UnsupportedOperationException("Setting the format for Date, Time or DateTime fields not supported in this method.");
        }

        if (elementCache().formatInput.getComponentElement().isDisplayed())
        {
            elementCache().formatInput.setValue(formatString);
        }
        else if (elementCache().charScaleInput.getComponentElement().isDisplayed())
        {
            // Formatting of Boolean types use the scale input.
            elementCache().charScaleInput.setValue(formatString);
        }
        else
        {
            throw new NullPointerException("No 'Format' input present to set.");
        }

        return this;
    }

    public String getFormat()
    {
        expand();

        if(elementCache().formatInput.getComponentElement().isDisplayed())
        {
            return elementCache().formatInput.getValue();
        }
        else if(elementCache().charScaleInput.getComponentElement().isDisplayed())
        {
            // Formatting of Boolean types use the scale input.
            return elementCache().charScaleInput.getValue();
        }
        else
        {
            throw new NullPointerException("No 'Format' input present to get.");
        }
    }

    public WebElement getFormatControl()
    {
        if(elementCache().formatInput.getComponentElement().isDisplayed())
        {
            return elementCache().formatInput.getComponentElement();
        }
        else if(elementCache().charScaleInput.getComponentElement().isDisplayed())
        {
            // Formatting of Boolean types use the scale input.
            return elementCache().charScaleInput.getComponentElement();
        }
        else
        {
            return null;
        }
    }

    //
    // string field options.

    public DomainFieldRow allowMaxChar()
    {
        expand();
        elementCache().allowMaxCharCountRadio.set(true);
        return this;
    }

    public boolean isMaxCharDefault()
    {
        expand();
        return elementCache().allowMaxCharCountRadio.isChecked();
    }

    public DomainFieldRow setCharCount(int maxCharCount)
    {
        expand();
        String strCharCount = Integer.toString(maxCharCount);
        elementCache().setCharCountRadio.set(true);
        WebDriverWrapper.waitFor(() -> !isCharCountDisabled(),
                "character count input did not become enabled in time", 1000);
        elementCache().charScaleInput.setValue(strCharCount);
        return this;
    }

    public boolean isCharCountDisabled()
    {
        return elementCache().charScaleInput.getComponentElement().getAttribute("disabled") != null;
    }

    public boolean isFieldProtected()
    {
        return elementCache().fieldNameInput.getComponentElement().getAttribute("disabled") != null;
    }

    public boolean isCustomCharSelected()
    {
        expand();
        return elementCache().setCharCountRadio.isChecked();
    }

    public Integer getCustomCharCount()
    {
        expand();
        return Integer.parseInt(elementCache().charScaleInput.getValue());
    }

    public boolean isMaxTextLengthPresent(int rowIndex)
    {
        return getWrapper().isElementPresent(elementCache().getCharScaleInputLocForRow(rowIndex));
    }

    // barcode- scannable options

    /**
     *  Indicates that the field should be searched when
     */
    public boolean isFieldScannable()
    {
        expand();
        return elementCache().scannableCheckbox.get();
    }

    public DomainFieldRow setFieldScannable(boolean checked)
    {
        expand();
        elementCache().scannableCheckbox.set(checked);
        return this;
    }

    public boolean isScannableCheckboxPresent()
    {
        expand();
        return elementCache().scannableCheckboxLoc.existsIn(this);
    }

    // lookup options.

    public DomainFieldRow setLookup(FieldDefinition.LookupInfo lookupInfo)
    {
        setType(FieldDefinition.ColumnType.Lookup);
        setFromFolder(lookupInfo.getFolder());
        setFromSchema(lookupInfo.getSchema());
        String tableType;
        if (lookupInfo.getTableType() == FieldDefinition.ColumnType.Integer)
            tableType = "Integer";
        else if (lookupInfo.getTableType() == FieldDefinition.ColumnType.String)
            tableType = "String";
        else
            throw new IllegalArgumentException("Invalid lookup type specified for " + lookupInfo.getTable() + ": " + lookupInfo.getTableType());

        setFromTargetTable(lookupInfo.getTable() + " (" + tableType + ")");
        return this;
    }

    public String getFromFolder()
    {
        expand();
        return elementCache().lookupContainerSelect.getFirstSelectedOption().getText();
    }

    public DomainFieldRow setFromFolder(String containerPath)
    {
        expand();
        if (StringUtils.isBlank(containerPath) || containerPath.equals("Current Folder") || containerPath.equals("Current Project"))
        {
            containerPath = "";
        }
        WebDriverWrapper.waitFor(() -> Locator.tagContainingText("option","Current Project")
                .findOptionalElement(elementCache().lookupContainerSelect.getWrappedElement()).isPresent(), 2000);
        String initialValue = elementCache().lookupContainerSelect.getFirstSelectedOption().getAttribute("value");
        if (!containerPath.equals(initialValue))
        {
            getWrapper().scrollIntoView(elementCache().lookupContainerSelect.getWrappedElement(), true);
            elementCache().lookupContainerSelect.selectByValue(containerPath);
            getWrapper().shortWait().withMessage("Schema select didn't clear after selecting lookup container")
                    .until(ExpectedConditions.domPropertyToBe(elementCache().getLookupSchemaSelect().getWrappedElement(), "value", ""));
        }

        return this;
    }

    public String getFromSchema()
    {
        expand();
        return elementCache().getLookupSchemaSelect().getFirstSelectedOption().getText();
    }

    public DomainFieldRow setFromSchema(String schemaName)
    {
        expand();
        WebDriverWrapper.waitFor(() -> Locator.tagContainingText("option","core")
                .findOptionalElement(elementCache().getLookupSchemaSelect().getWrappedElement()).isPresent(), 2000);
        String initialValue = elementCache().getLookupSchemaSelect().getFirstSelectedOption().getText();
        if (!schemaName.equals(initialValue))
        {
            getWrapper().scrollIntoView(elementCache().getLookupSchemaSelect().getWrappedElement(), true);
            elementCache().getLookupSchemaSelect().selectByVisibleText(schemaName);
            getWrapper().shortWait().withMessage("Query select didn't update after selecting lookup schema")
                    .until(ExpectedConditions.domPropertyToBe(elementCache().getLookupQuerySelect().getWrappedElement(), "value", ""));
        }
        return this;
    }

    public String getFromTargetTable()
    {
        expand();
        return elementCache().getLookupQuerySelect().getFirstSelectedOption().getText();
    }

    public DomainFieldRow setFromTargetTable(String targetTable)
    {
        expand();
        elementCache().getLookupQuerySelect().selectByVisibleText(targetTable);
        return this;
    }

    public boolean getLookupValidatorEnabled()
    {
        expand();
        return elementCache().getLookupValidatorEnabledCheckbox().get();
    }

    public DomainFieldRow setLookupValidatorEnabled(boolean checked)
    {
        expand();
        elementCache().getLookupValidatorEnabledCheckbox().set(checked);
        return this;
    }

    // ontology lookup settings

    public DomainFieldRow setOntology(String ontology, String importField, String labelField)
    {
        setType(FieldDefinition.ColumnType.OntologyLookup);
        setSelectedOntology(ontology)
                .setConceptImportField(importField)
                .setConceptLabelField(labelField);
        return this;
    }

    public String getSelectedOntology()
    {
        expand();
        return elementCache().getOntologySelect().getFirstSelectedOption().getAttribute("value");
    }

    public DomainFieldRow setSelectedOntology(String ontology)
    {
        expand();
        elementCache().getOntologySelect().selectByValue(ontology);
        return this;
    }

    public DomainFieldRow setConceptImportField(String importField)
    {
        expand();
        elementCache().getConceptImportFieldSelect().selectByVisibleText(importField);
        return this;
    }

    public String getConceptImportField()
    {
        expand();
        return elementCache().getConceptImportFieldSelect().getFirstSelectedOption().getText();
    }

    /**
     * Allows test code to get which ontologies are available for selection
     *
     * @return a list of the full text shown in the options
     */
    public List<String> getConceptImportSelectOptions()
    {
        expand();
        return getWrapper().getTexts(elementCache().getOntologySelect().getOptions());
    }

    public DomainFieldRow setConceptLabelField(String labelField)
    {
        expand();
        elementCache().getConceptLabelFieldSelect().selectByVisibleText(labelField);
        return this;
    }

    public String getConceptLabelField()
    {
        expand();
        return elementCache().getConceptLabelFieldSelect().getFirstSelectedOption().getText();
    }

    public ConceptPickerDialog clickExpectedVocabulary()
    {
        expand();
        elementCache().expectedVocabularyButton().click();
        return new ConceptPickerDialog(new ModalDialog.ModalDialogFinder(getDriver()).withTitle("Expected Vocabulary"));
    }

    public ConceptPickerDialog clickSelectConcept()
    {
        expand();
        elementCache().selectConceptButton().click();
        return new ConceptPickerDialog(new ModalDialog.ModalDialogFinder(getDriver()).withTitle("Select Concept"));
    }

    public Optional<WebElement> optionalExpectedVocabularyLink()
    {
        expand();
        return elementCache().selectedVocabularyLink();
    }

    public DomainFieldRow clickRemoveExpectedVocabulary()
    {
        expand();
        WebDriverWrapper.waitFor(() -> elementCache().removeSelectedVocabularyLink().isPresent(),
                "the expected vocabulary link is not present", 2000);
        elementCache().removeSelectedVocabularyLink().get().click();
        return this;
    }

    public Optional<WebElement> optionalOntologyConceptLink()
    {
        expand();
        return elementCache().selectedConceptLink();
    }

    public DomainFieldRow clickRemoveOntologyConcept()
    {
        expand();
        WebDriverWrapper.waitFor(() -> elementCache().selectedConceptLink().isPresent(),
                "the expected ontology link is not present", 2000);
        elementCache().removeSelectedConceptLink().get().click();
        return this;
    }

    // TextChoice Field settings
    //
    // To a user a TextChoice field looks and behaves a lot like a lookup, even though it is implemented using a validator
    // behind the scenes. Because of that the validator aspect of the TextChoice field is hidden from the user (just like
    // it is in the product).

    public void setAllowMultipleSelections(Boolean allowMultipleSelections)
    {
        elementCache().allowMultipleSelectionsCheckbox.set(allowMultipleSelections);
    }

    /**
     * Set the list of allowed values for a TextChoice field.
     *
     * @param values List of values (Strings).
     * @return A reference to this field row.
     */
    public DomainFieldRow setTextChoiceValues(List<String> values)
    {
        WebElement button = Locator.tagWithClass("span", "container--action-button").withText("Add Values").findElement(this);
        button.click();

        TextChoiceValueDialog addValuesDialog = new TextChoiceValueDialog(this);
        addValuesDialog.addValues(values);
        return addValuesDialog.clickApply();
    }

    /**
     * Get the displayed list of allowed values a TextChoice field.
     *
     * @return Values shown in the list for the TextChoice field.
     */
    public List<String> getTextChoiceValues()
    {
        // Intentionally using '.collect(Collectors.toList())' so the returned list is mutable (e.g. can sort it when
        // comparing against expected).
        return Locator.tagWithClass("button", "list-group-item").findElements(this)
                .stream().map(WebElement::getText).collect(Collectors.toList());
    }

    /**
     * Get a list of the values that are 'locked' for a TextChoice field. A locked value is one that has been applied and cannot be deleted.
     *
     * @return List of locked values.
     */
    public List<String> getLockedTextChoiceValues()
    {
        // Intentionally using '.collect(Collectors.toList())' so the returned list is mutable (e.g. can sort it when
        // comparing against expected).
        return Locator.tagWithClass("button", "list-group-item")
                .withDescendant(Locator.tagWithClass("span", "choices-list__locked"))
                .findElements(this)
                .stream().map(WebElement::getText).collect(Collectors.toList());
    }

    /**
     * Get a list of the values that are 'unlocked' for a TextChoice field. An unlocked value is one that has not been used.
     *
     * @return List of unlocked values.
     */
    public List<String> getUnlockedTextChoiceValues()
    {
        List<String> allChoices = getTextChoiceValues();
        allChoices.removeAll(getLockedTextChoiceValues());
        return allChoices;
    }

    /**
     * Enter a value into the search field for TextChoice values. If no values have been this will error with a
     * no-such-element exception.
     *
     * @param searchValue Value to search for.
     * @return List of values matching the search value.
     */
    public List<String> searchForTextChoiceValue(String searchValue)
    {
        WebElement searchTxtBox = Locator.tagWithClass("input", "domain-text-choices-search").findElement(this);
        getWrapper().setFormElement(searchTxtBox, searchValue);
        return getTextChoiceValues();
    }

    /**
     * Click on a value in the list of values for a TextChoice field. If the value is already selected this will have
     * no effect.
     *
     * @param value The value to click on.
     * @return This field row.
     */
    public DomainFieldRow selectTextChoiceValue(String value)
    {
        WebElement element = Locator.tagWithClass("button", "list-group-item").withText(value).findElement(this);
        element.click();
        return this;
    }

    /**
     * Check if the 'Apply' button is enabled for a TextChoice field. I will not be enabled if the value has not been
     * changed, or if it conflicts with an existing value. Note: The button is only visible if a value is selected.
     *
     * @return True if the button is enabled, false otherwise.
     */
    public boolean isTextChoiceApplyButtonEnabled()
    {
        WebElement button = Locator.button("Apply").findElement(this);
        return button.isEnabled();
    }

    /**
     * Enter text into the update textbox for a value. Note: The field is only visible if a value is selected.
     *
     * @param updatedValue Value to enter into the update textbox.
     * @return This field row.
     */
    public DomainFieldRow setUpdateTextChoiceValue(String updatedValue)
    {
        WebDriverWrapper.waitFor(this::isTextChoiceUpdateFieldEnabled,
                "The edit field for the TextChoice value did not become enabled in time.", 1_000);
        getWrapper().setFormElement(Locator.tagWithName("input", "value").findElement(this), updatedValue);
        return this;
    }

    private void updateValue(String originalValue, String newValue, boolean clickApply)
    {
        selectTextChoiceValue(originalValue);
        setUpdateTextChoiceValue(newValue);

        if(clickApply)
        {
            WebDriverWrapper.waitFor(this::isTextChoiceApplyButtonEnabled, "'Apply' button is not enabled.", 1_000);
            Locator.button("Apply").findElement(this).click();
        }
    }

    /**
     * Update the selected value in the TextChoice field. This will select the given field.
     *
     * @param originalValue The original value to select and change.
     * @param newValue The new value to replace it.
     * @return This field row.
     */
    public DomainFieldRow updateTextChoiceValue(String originalValue, String newValue)
    {
        WebElement alert = Locator.tagWithClass("div", "alert").findWhenNeeded(this);
        updateValue(originalValue, newValue, true);

        Assert.assertFalse("An unexpected alert was present after applying the change.",
                alert.isDisplayed());

        return this;
    }

    /**
     * Update a TextChoice value and expect an error. Can happen if the new value already exists in the list of values.
     *
     * @param originalValue The original value to select and change.
     * @param newValue The new value to replace it.
     * @return The error message.
     */
    public String updateTextChoiceValueExpectError(String originalValue, String newValue)
    {
        updateValue(originalValue, newValue, false);
        WebElement alert = BootstrapLocators.errorBanner.waitForElement(this, 1_000);
        return alert.getText();
    }

    /**
     * Update a TextChoice value that is currently being used and expect an info message with the number updated.
     *
     * @param originalValue The original value to select and change.
     * @param newValue The new value to replace it.
     * @return The info message indicating the number of entites updated.
     */
    public String updateLockedTextChoiceValue(String originalValue, String newValue)
    {
        updateValue(originalValue, newValue, true);
        WebElement alert = BootstrapLocators.infoBanner.waitForElement(this, 1_000);
        return alert.getText();
    }

    /**
     * Select a TextChoice value and check if the edit field is enabled.
     *
     * @param value The TextChoice value to select.
     * @return True if enabled, false otherwise.
     */
    public boolean isTextChoiceUpdateFieldEnabled(String value)
    {
        selectTextChoiceValue(value);
        return isTextChoiceUpdateFieldEnabled();
    }

    /**
     * Check if the edit field is enabled for the selected TextChoice value. A value must be selected.
     *
     * @return True if enabled, false otherwise.
     */
    public boolean isTextChoiceUpdateFieldEnabled()
    {
        WebElement updateField = Locator.tagWithName("input", "value").findWhenNeeded(this);

        Assert.assertTrue("Update field is not visible, make sure a TextChoice value is selected.",
                updateField.isDisplayed());

        return updateField.isEnabled();
    }

    /**
     * Check to see if the 'Delete' button is enabled for a TextChoice field. Note: The button is only visible if a
     * value is selected.
     *
     * @return True if the button is enabled, false otherwise.
     */
    public boolean isTextChoiceDeleteButtonEnabled()
    {
        WebElement button = Locator.buttonContainingText("Delete").findElement(this);
        return button.isEnabled();
    }

    /**
     * Delete a value from the list of values for a TextChoice field. This will select the value before deleting it.
     *
     * @param value The value to delete.
     * @return This field row.
     */
    public DomainFieldRow deleteTextChoiceValue(String value)
    {
        selectTextChoiceValue(value);
        WebElement button = Locator.buttonContainingText("Delete").refindWhenNeeded(this);
        WebDriverWrapper.waitFor(button::isEnabled, "'Delete' button is not enabled.", 1_000);
        button.click();
        WebDriverWrapper.waitFor(()->!button.isDisplayed(), "Deleting TextChoice value did not complete.", 1_000);
        return this;
    }

    // Calculations field settings

    public DomainFieldRow setValueExpression(String expression)
    {
        if (!isExpanded())
            expand();

        getWrapper().setFormElement(elementCache().expressionInput, expression);
        clickValidateExpression();
        return this;
    }

    private void clickValidateExpression()
    {
        elementCache().expressionValidateLink.click();

        getWrapper().shortWait().until(ExpectedConditions.or(
                ExpectedConditions.visibilityOf(elementCache().expressionStatusValidated),
                ExpectedConditions.visibilityOf(elementCache().expressionStatusError)));
    }

    public String getValueExpressionStatusMessage()
    {
        String statusMsg = "";
        if(waitFor(elementCache().expressionStatusMsg::isDisplayed, 1_000))
        {
            statusMsg = elementCache().expressionStatusMsg.getText();
        }
        return statusMsg;
    }

    public String getValueExpression()
    {
        if (!isExpanded())
            expand();

        return getWrapper().getFormElement(elementCache().expressionInput);
    }

    // advanced settings

    public DomainFieldRow showFieldOnDefaultView(boolean checked)
    {
        clickAdvancedSettings()
                .showInDefaultView(checked)
                .apply();
        return this;
    }

    public DomainFieldRow showFieldOnInsertView(boolean checked)
    {
        clickAdvancedSettings()
                .showInInsertView(checked)
                .apply();
        return this;
    }

    public DomainFieldRow showFieldOnUpdateView(boolean checked)
    {
        clickAdvancedSettings()
                .showInUpdateView(checked)
                .apply();
        return this;
    }

    public DomainFieldRow showFieldOnDetailsView(boolean checked)
    {
        clickAdvancedSettings()
                .showInDetailsView(checked)
                .apply();
        return this;
    }

    public DomainFieldRow setPHILevel(FieldDefinition.PhiSelectType phiLevel)
    {
        clickAdvancedSettings()
                .setPHILevel(phiLevel)
                .apply();
        return this;
    }

    public DomainFieldRow setExcludeFromDateShifting(boolean shift)
    {
        clickAdvancedSettings()
                .excludeFromDateShifting(shift)
                .apply();
        return this;
    }

    public DomainFieldRow setMeasure(boolean checked)
    {
        clickAdvancedSettings()
                .setMeasure(checked)
                .apply();
        return this;
    }

    public DomainFieldRow setDimension(boolean checked)
    {
        clickAdvancedSettings()
                .setDimension(checked)
                .apply();
        return this;
    }

    public DomainFieldRow setRecommendedVariable(boolean checked)
    {
        clickAdvancedSettings()
                .setRecommendedVariable(checked)
                .apply();
        return this;
    }

    public DomainFieldRow setMissingValuesEnabled(boolean checked)
    {
        clickAdvancedSettings()
                .setMissingValuesEnabled(checked)
                .apply();
        return this;
    }

    // error and warning

    public boolean hasFieldError()
    {
        return getComponentElement().getAttribute("class").contains("domain-row-border-error");
    }

    public DomainFieldRow waitForError()
    {
        WebDriverWrapper.waitFor(this::hasFieldError, WAIT_FOR_JAVASCRIPT);
        return this;
    }

    public boolean hasFieldWarning()
    {
        return getComponentElement().getAttribute("class").contains("domain-row-border-warning");
    }

    public DomainFieldRow waitForWarning()
    {
        WebDriverWrapper.waitFor(this::hasFieldWarning, WAIT_FOR_JAVASCRIPT);
        return this;
    }

    public String getWarningMessage()
    {
        String warningMsg = "";
        WebElement warningMsgElement = Locator.byClass("domain-row-warning").findWhenNeeded(this);
        if(warningMsgElement.isDisplayed())
            warningMsg = warningMsgElement.getText();

        return warningMsg;
    }

    // conditional formatting and validation options

    /**
     * appends the supplied validators to any existing ones (including any empty default ones that might exist)
     */
    public DomainFieldRow addRangeValidators(List<FieldDefinition.RangeValidator> validators)
    {
        RangeValidatorDialog dialog = clickRangeButton();
        for (FieldDefinition.RangeValidator val : validators)
        {
            dialog.addValidator(val);
        }
        dialog.clickApply();
        return this;
    }

    /**
     * sets the supplied validators on the field, assumes none are already present
     */
    public DomainFieldRow setRangeValidators(List<FieldDefinition.RangeValidator> validators)
    {
        RangeValidatorDialog dialog = clickRangeButton();
        for (int i = 0; i < validators.size(); i++)
        {
            dialog.setValidator(i, validators.get(i));
        }
        dialog.clickApply();
        return this;
    }

    public RangeValidatorDialog clickRangeButton()
    {
        expand();
        getWrapper().shortWait().until(ExpectedConditions.elementToBeClickable(elementCache().rangeButton()));
        elementCache().rangeButton().click();
        return new RangeValidatorDialog(this);
    }

    /**
     * adds the specified regexValidators to the field.  Assumes that any range panels in the dialog
     * are complete (by default, the first one is already shown but is empty)
     * When adding the first/only regex validators to the field, use setRegularExpressions
     */
    public DomainFieldRow addRegularExpressions(List<FieldDefinition.RegExValidator> validators)
    {
        RegexValidatorDialog dialog = clickRegexButton();
        for (FieldDefinition.RegExValidator val : validators)
        {
            dialog.addValidator(val);
        }
        dialog.clickApply();
        return this;
    }

    public DomainFieldRow setRegExValidators(List<FieldDefinition.RegExValidator> validators)
    {
        RegexValidatorDialog dialog = clickRegexButton();
        for (int i = 0; i < validators.size(); i++)
        {
            dialog.setValidator(i, validators.get(i));
        }
        dialog.clickApply();
        return this;
    }

    public RegexValidatorDialog clickRegexButton()
    {
        expand();
        getWrapper().shortWait().until(ExpectedConditions.elementToBeClickable(elementCache().regexValidatorButton()));
        elementCache().regexValidatorButton().click();
        return new RegexValidatorDialog(this);
    }

    public ConditionalFormatDialog clickConditionalFormatButton()
    {
        expand();
        getWrapper().shortWait().until(ExpectedConditions.elementToBeClickable(elementCache().conditionalFormatButton()));
        elementCache().conditionalFormatButton().click();
        return new ConditionalFormatDialog(this);
    }

    public boolean hasHitSelectionCriteriaBtn()
    {
        return elementCache().hitSelectionCriteriaBtnLoc.existsIn(this);
    }

    public HitSelectionDialog clickHitSelectionCriteriaButton()
    {
        expand();
        getWrapper().shortWait().until(ExpectedConditions.elementToBeClickable(elementCache().hitSelectionCriteriaButton()));
        elementCache().hitSelectionCriteriaButton().click();
        return new HitSelectionDialog(getDriver());
    }

    public List<String> getHitSelectionCriteria()
    {
        expand();
        return elementCache().hitSelectionCriteria();
    }

    @Override
    protected ElementCache newElementCache()
    {
        return new ElementCache();
    }

    public String getSampleType()
    {
        expand();
        return elementCache().getLookupSampleTypeSelect().getFirstSelectedOption().getText();
    }

    public DomainFieldRow setSampleType(String sampleTypeName)
    {
        expand();
        getWrapper().scrollIntoView(elementCache().getLookupSampleTypeSelect().getWrappedElement(), true);
        elementCache().getLookupSampleTypeSelect().selectByVisibleText(sampleTypeName);
        return this;
    }

    public List<String> getAvailableSampleTypes()
    {
        expand();
        return elementCache().getLookupSampleTypeSelect().getOptions().stream().map(WebElement::getText).collect(Collectors.toList());
    }

    public DomainFieldRow setAliquotOption(ExpSchema.DerivationDataScopeType option)
    {
        expand();
        RadioButton button = elementCache().aliquotOption(option);
        button.check();
        return this;
    }

    public RadioButton getAliquotOptionRadioButton(ExpSchema.DerivationDataScopeType option)
    {
        expand();
        return elementCache().aliquotOption(option);
    }

    public ExpSchema.DerivationDataScopeType getSelectedAliquotOption()
    {
        expand();
        for (ExpSchema.DerivationDataScopeType option : ExpSchema.DerivationDataScopeType.values())
        {
            if (elementCache().aliquotOption(option).isChecked())
                return option;
        }
        return null;
    }

    public boolean hasAliquotOptionWarning()
    {
        expand();
        return getWrapper().isElementPresent(elementCache().aliquotWarningAlert);
    }

    public String getAliquotOptionWarning()
    {
        return elementCache().aliquotWarningAlert.findElement(this).getText();
    }

    // date field options.
    private String getFormatWithoutExample(String format)
    {
        int index = format.indexOf(" (");
        if (index == -1)
            return format;

        return format.substring(0, index);
    }

    public DomainFieldRow setDateTimeInherited(boolean check)
    {
        expand();
        elementCache().dateTimeInheritedCheckbox.set(check);
        return this;
    }

    public boolean isDateTimeInherited()
    {
        return elementCache().dateTimeInheritedCheckbox.get();
    }

    public DomainFieldRow setDateTimeFormat(DATE_FORMAT date, TIME_FORMAT time)
    {
        setDateTimeFormat(date);
        setDateTimeFormat(time);
        return this;
    }

    public DomainFieldRow setDateTimeFormat(DATE_FORMAT dateFormat)
    {
        expand();
        if (isDateTimeInherited())
            setDateTimeInherited(false);

        String txt;

        if (dateFormat.equals(DATE_FORMAT.DATETIME))
        {
            txt = dateFormat.toString();
        }
        else
        {
            txt = dateFormat + " (";
        }

        elementCache().dateTimeFormatDateSelect.typeAheadSelect(txt);
        return this;
    }

    public DomainFieldRow setDateTimeFormat(TIME_FORMAT timeFormat)
    {
        expand();
        if (isDateTimeInherited())
            setDateTimeInherited(false);
        elementCache().dateTimeFormatTimeSelect.typeAheadSelect(TIME_FORMAT.none.equals(timeFormat) ? timeFormat.toString() : timeFormat + " (");
        return this;
    }

    public String getDateTimeFormatDate()
    {
        String formatValue;

        if(elementCache().dateTimeFormatDateSelect.isInteractive())
        {
            formatValue = getFormatWithoutExample(elementCache().dateTimeFormatDateSelect.getValue());
        }
        else
        {
            formatValue = getFormatWithoutExample(elementCache().disabledDateTimeDateFormat.getText());
        }

        return formatValue;
    }

    public List<String> getDateTimeFormatDateOptions()
    {
        ArrayList<String> formatValues = new ArrayList<>();
        for (String formatOption : elementCache().dateTimeFormatDateSelect.getOptions())
        {
            formatValues.add(getFormatWithoutExample(formatOption));
        }
        return formatValues;
    }

    public boolean isDateTimeFormatDateEnabled()
    {
        return elementCache().dateTimeFormatDateSelect.isInteractive();
    }

    public String getDateTimeFormatTime()
    {
        String formatValue;

        if(elementCache().dateTimeFormatTimeSelect.isInteractive())
        {
            formatValue = getFormatWithoutExample(elementCache().dateTimeFormatTimeSelect.getValue());
        }
        else
        {
            formatValue = getFormatWithoutExample(elementCache().disabledDateTimeTimeFormat.getText());
        }

        return formatValue;
    }

    public List<String> getDateTimeFormatTimeOptions()
    {
        ArrayList<String> formatValues = new ArrayList<>();
        for (String formatOption : elementCache().dateTimeFormatTimeSelect.getOptions())
            {
                formatValues.add(getFormatWithoutExample(formatOption));
            }
        return formatValues;
    }

    public boolean isDateTimeFormatTimeEnabled()
    {
        return elementCache().dateTimeFormatTimeSelect.isInteractive();
    }

    public String getDateTimeFormat()
    {
        String date = getDateTimeFormatDate();
        String time = getDateTimeFormatTime();
        if (TIME_FORMAT.none.toString().equals(time) || StringUtils.isEmpty(time))
            return date;

        return date + " " + time;
    }

    public DomainFieldRow setDateInherited(boolean check)
    {
        expand();
        elementCache().dateInheritedCheckbox.set(check);
        return this;
    }

    public boolean isDateInherited()
    {
        return elementCache().dateInheritedCheckbox.get();
    }

    public String getDateFormat()
    {
        String formatValue;

        if(elementCache().dateFormatSelect.isInteractive())
        {
            formatValue = getFormatWithoutExample(elementCache().dateFormatSelect.getValue());
        }
        else
        {
            formatValue = getFormatWithoutExample(elementCache().disabledDateFormat.getText());
        }

        return formatValue;
    }

    public List<String> getDateFormatOptions()
    {
        List<String> options = new ArrayList<>();
        for (String option : elementCache().dateFormatSelect.getOptions())
            {
                options.add(getFormatWithoutExample(option));
            }
        return options;
    }

    public boolean isDateFormatEnabled()
    {
        return elementCache().dateFormatSelect.isInteractive();
    }

    public DomainFieldRow setDateFormat(DATE_FORMAT dateFormat)
    {
        expand();
        if (isDateInherited())
            setDateInherited(false);

        String txt;
        if (dateFormat.equals(DATE_FORMAT.DATE))
        {
            txt = dateFormat.toString();
        }
        else
        {
            txt = dateFormat + " (";
        }
        elementCache().dateFormatSelect.typeAheadSelect(txt);

        return this;
    }

    public DomainFieldRow setTimeInherited(boolean check)
    {
        expand();
        elementCache().timeInheritedCheckbox.set(check);
        return this;
    }

    public boolean isTimeInherited()
    {
        return elementCache().timeInheritedCheckbox.get();
    }

    public String getTimeFormat()
    {
        String formatValue;

        if(elementCache().timeFormatSelect.isInteractive())
        {
            formatValue = getFormatWithoutExample(elementCache().timeFormatSelect.getValue());
        }
        else
        {
            formatValue = getFormatWithoutExample(elementCache().disabledTimeFormat.getText());
        }

        return formatValue;
    }

    public List<String> getTimeFormatOptions()
    {
        ArrayList<String> formatValues = new ArrayList<>();
        for (String formatOption : elementCache().timeFormatSelect.getOptions())
        {
            formatValues.add(getFormatWithoutExample(formatOption));
        }
        return formatValues;
    }

    public boolean isTimeFormatEnabled()
    {
        return elementCache().timeFormatSelect.isInteractive();
    }

    public DomainFieldRow setTimeFormat(TIME_FORMAT timeFormat)
    {
        expand();
        if (isTimeInherited())
            setTimeInherited(false);

        String txt;

        if (timeFormat.equals(TIME_FORMAT.TIME))
        {
            txt = timeFormat.toString();
        }
        else
        {
            txt = timeFormat + " (";
        }

        elementCache().timeFormatSelect.typeAheadSelect(txt);
        return this;
    }

    public boolean hasDomainWarningIcon()
    {
        return elementCache().domainWarningIcon.isDisplayed();
    }

    public WebElement getDomainWarningIcon()
    {
        return elementCache().domainWarningIcon;
    }

    public static class DomainFieldRowFinder extends WebDriverComponentFinder<DomainFieldRow, DomainFieldRowFinder>
    {
        private final Locator.XPathLocator _baseLocator = Locator.tagWithClassContaining("div", "domain-field-row").withoutClass("domain-floating-hdr");
        private String _title = null;
        private final DomainFormPanel _domainFormPanel;

        public DomainFieldRowFinder(DomainFormPanel panel, WebDriver driver)
        {
            super(driver);
            _domainFormPanel = panel;
        }

        public DomainFieldRowFinder withTitle(String title)
        {
            _title = title;
            return this;
        }

        @Override
        protected DomainFieldRow construct(WebElement el, WebDriver driver)
        {
            return new DomainFieldRow(_domainFormPanel, el, driver);
        }

        @Override
        protected Locator locator()
        {
            if (_title != null)
                return _baseLocator.withAttribute("title", _title);
            else
                return _baseLocator;
        }
    }

    protected class ElementCache extends WebDriverComponent.ElementCache
    {
        // base row controls
        public final Input fieldNameInput = new Input(Locator.tagWithAttributeContaining("input", "id", "domainpropertiesrow-name-")
                .findWhenNeeded(this), getDriver());
        public final Select fieldTypeSelectInput = SelectWrapper.Select(Locator.tagWithAttributeContaining("select", "id", "domainpropertiesrow-type-"))
                .findWhenNeeded(this);
        public final Checkbox fieldRequiredCheckbox = new Checkbox(Locator.tagWithAttributeContaining("input", "id", "domainpropertiesrow-required-")
                .findWhenNeeded(this));

        public final Checkbox fieldSelectCheckbox = new Checkbox(Locator.tagWithAttributeContaining("input", "id", "domainpropertiesrow-selected")
                .findWhenNeeded(this));

        public final WebElement fieldDetailsMessage = Locator.css(".domain-field-details, .domain-field-details-expanded")
                .findWhenNeeded(this);


        public final Locator expandToggleLoc = Locator.tagWithClass("div", "field-icon")
                .child(Locator.tagWithClassContaining("span", "fa-chevron-right"));
        public final Locator collapseToggleLoc = Locator.tagWithClass("div", "field-icon")
                .child(Locator.tagWithClassContaining("span", "fa-chevron-down"));
        public final WebElement expandToggle = expandToggleLoc.findWhenNeeded(this);

        public final Locator removeFieldLoc = Locator.tagWithClass("span", "field-icon")
                .child(Locator.tagWithClassContaining("span", "domain-field-delete-icon"));
        public final WebElement removeField = removeFieldLoc.findWhenNeeded(this);

        // controls revealed when expanded
        public final WebElement advancedSettingsBtn = Locator.button("Advanced Settings")      // not enabled for now, placeholder
                .refindWhenNeeded(this).withTimeout(WAIT_FOR_JAVASCRIPT);
        public final WebElement collapseToggle = collapseToggleLoc.refindWhenNeeded(this).withTimeout(WAIT_FOR_JAVASCRIPT);


        // common field options
        public final WebElement descriptionTextArea = Locator.tagWithAttributeContaining("textarea", "id", "domainpropertiesrow-description-")
                .refindWhenNeeded(this);
        public final Input labelInput = new Input(Locator.tagWithAttributeContaining("input", "id", "domainpropertiesrow-label-")
                .refindWhenNeeded(this), getDriver());
        public final Input importAliasesInput = new Input(Locator.tagWithAttributeContaining("input", "id", "domainpropertiesrow-importAliases-")
                .refindWhenNeeded(this), getDriver());
        public final Input urlInput = new Input(Locator.tagWithAttributeContaining("input", "id", "domainpropertiesrow-URL-")
                .refindWhenNeeded(this), getDriver());
        protected final Locator urlTargetCheckboxLoc = Locator.input("domainpropertiesrow-isTargetBlank");
        public final Checkbox urlTargetCheckbox = new Checkbox(urlTargetCheckboxLoc.refindWhenNeeded(this).withTimeout(WAIT_FOR_JAVASCRIPT));

        // numeric field options
        public final Select defaultScaleTypeSelect = SelectWrapper.Select(Locator.name("domainpropertiesrow-defaultScale"))
                .findWhenNeeded(this);

        // text field options
        public final RadioButton allowMaxCharCountRadio = new RadioButton(Locator.tagWithAttributeContaining("input", "id", "domainpropertiesrow-maxLength-")
                .refindWhenNeeded(this));
        public final RadioButton setCharCountRadio = new RadioButton(Locator.tagWithAttributeContaining("input", "id", "domainpropertiesrow-customLength-")
                .refindWhenNeeded(this));
        public final Input charScaleInput = new Input(Locator.tagWithAttributeContaining("input", "id", "domainpropertiesrow-scale")
                .refindWhenNeeded(this), getDriver());

        // barcode option
        protected final Locator scannableCheckboxLoc = Locator.input("domainpropertiesrow-scannable");
        public final Checkbox scannableCheckbox = new Checkbox(scannableCheckboxLoc.refindWhenNeeded(this).withTimeout(WAIT_FOR_JAVASCRIPT));

        public final Input formatInput = new Input(Locator.tagWithAttributeContaining("input", "id", "domainpropertiesrow-format")
                .refindWhenNeeded(this), getDriver());

        public final Checkbox dateInheritedCheckbox = new Checkbox(Locator.input("domainpropertiesrow-format_inheritdate")
                .refindWhenNeeded(this).withTimeout(WAIT_FOR_JAVASCRIPT));
        public final Checkbox dateTimeInheritedCheckbox = new Checkbox(Locator.input("domainpropertiesrow-format_inheritdateTime")
                .refindWhenNeeded(this).withTimeout(WAIT_FOR_JAVASCRIPT));
        public final Checkbox timeInheritedCheckbox = new Checkbox(Locator.input("domainpropertiesrow-format_inherittime")
                .refindWhenNeeded(this).withTimeout(WAIT_FOR_JAVASCRIPT));
        public final FilteringReactSelect dateTimeFormatDateSelect = FilteringReactSelect.finder(getDriver())
                .withNamedInput("domainpropertiesrow-format_datedateTime")
                .refindWhenNeeded(this);
        public final WebElement disabledDateTimeDateFormat = Locator.tagWithAttributeContaining("div", "id", "domainpropertiesrow-format_datedateTime")
                .descendant("div[contains(@class,'select-input__single-value--is-disabled')]").findWhenNeeded(this);
        public final FilteringReactSelect dateTimeFormatTimeSelect = FilteringReactSelect.finder(getDriver())
                .withNamedInput("domainpropertiesrow-format_timedateTime")
                .refindWhenNeeded(this);
        public final WebElement disabledDateTimeTimeFormat = Locator.tagWithAttributeContaining("div", "id", "domainpropertiesrow-format_timedateTime")
                .descendant("div[contains(@class,'select-input__single-value--is-disabled')]").findWhenNeeded(this);
        public final FilteringReactSelect dateFormatSelect = FilteringReactSelect.finder(getDriver())
                .withNamedInput("domainpropertiesrow-format_datedate")
                .refindWhenNeeded(this);
        public final WebElement disabledDateFormat = Locator.tagWithAttributeContaining("div", "id", "domainpropertiesrow-format_datedate")
                .descendant("div[contains(@class,'select-input__single-value--is-disabled')]").findWhenNeeded(this);
        public final FilteringReactSelect timeFormatSelect = FilteringReactSelect.finder(getDriver())
                .withNamedInput("domainpropertiesrow-format_timetime")
                .refindWhenNeeded(this);
        public final WebElement disabledTimeFormat = Locator.tagWithAttributeContaining("div", "id", "domainpropertiesrow-format_timetime")
                .descendant("div[contains(@class,'select-input__single-value--is-disabled')]").findWhenNeeded(this);
        public final WebElement domainWarningIcon = Locator.tagWithClass("span", "domain-warning-icon")
                .findWhenNeeded(this);

        // text choice field option
        public final Checkbox allowMultipleSelectionsCheckbox = new Checkbox(Locator.tagWithClass("input", "domain-text-choice-multi")
                .refindWhenNeeded(this).withTimeout(WAIT_FOR_JAVASCRIPT));

        // lookup field options
        public final Select lookupContainerSelect = SelectWrapper.Select(Locator.name("domainpropertiesrow-lookupContainer"))
                .findWhenNeeded(this);
        Locator.XPathLocator selectVocabularyBtnLoc = Locator.tagWithAttribute("button", "name", "domainpropertiesrow-principalConceptCode")
                .withText("Expected Vocabulary");
        Locator.XPathLocator selectConceptBtnLoc = Locator.tagWithAttribute("button", "name", "domainpropertiesrow-principalConceptCode")
                .withText("Select Concept");

        // calculations field options
        public final WebElement expressionInput = Locator.name("domainpropertiesrow-valueExpression")
                .findWhenNeeded(this);
        private final Locator.XPathLocator expressionStatusMsgLoc = Locator.tagWithClass("div", "domain-field-calc-footer");
        public final WebElement expressionStatusValidated = expressionStatusMsgLoc.child(Locator.tagWithClass("div", "validated")).refindWhenNeeded(this);
        public final WebElement expressionStatusError = expressionStatusMsgLoc.child(Locator.tagWithClass("div", "error")).refindWhenNeeded(this);
        public final WebElement expressionStatusMsg = expressionStatusMsgLoc.childTag("div").refindWhenNeeded(this);
        public final WebElement expressionValidateLink = expressionStatusMsgLoc.child(Locator.tagWithClass("div", "validate-link")).refindWhenNeeded(this);

        Locator.XPathLocator aliquotWarningAlert = Locator.tagWithClassContaining("div", "aliquot-alert-warning");

        public Locator.XPathLocator getCharScaleInputLocForRow(int rowIndex)
        {
            return Locator.tagWithId("input", "domainpropertiesrow-scale-0-" + rowIndex);
        }

        public Select getLookupSchemaSelect()
        {
            Select select = SelectWrapper.Select(Locator.name("domainpropertiesrow-lookupSchema")).find(this);
            return waitForSelectToLoad(select);
        }

        public Select getLookupQuerySelect()
        {
            Select select = SelectWrapper.Select(Locator.name("domainpropertiesrow-lookupQueryValue")).find(this);
            return waitForSelectToLoad(select);
        }

        public Select getLookupSampleTypeSelect()
        {
            Select select = SelectWrapper.Select(Locator.name("domainpropertiesrow-sampleTypeSelect")).find(this);
            return waitForSelectToLoad(select);
        }

        // ontology lookup settings
        public Select getOntologySelect()
        {
            Select select = SelectWrapper.Select(Locator.tagWithAttributeContaining("select", "id", "domainpropertiesrow-sourceOntology")).waitFor(this);
            return waitForSelectToLoad(select);
        }

        public Select getConceptImportFieldSelect()
        {
            Select select = SelectWrapper.Select(
                    Locator.tagWithAttributeContaining("select", "id", "domainpropertiesrow-conceptImportColumn"))
                    .waitFor(this);
            return waitForSelectToLoad(select);
        }

        public Select getConceptLabelFieldSelect()
        {
            Select select = SelectWrapper.Select(
                    Locator.tagWithAttributeContaining("select", "id", "domainpropertiesrow-conceptLabelColumn"))
                    .waitFor(this);
            return waitForSelectToLoad(select);
        }

        public WebElement expectedVocabularyButton()
        {
            return selectVocabularyBtnLoc.waitForElement(this, 2000);
        }

        public WebElement selectConceptButton()
        {
            return selectConceptBtnLoc.waitForElement(this, 2000);
        }

        Optional<WebElement> selectedVocabularyLink()
        {
            return Locator.tagWithClass("table", "domain-annotation-table")
                    .withDescendant(selectVocabularyBtnLoc)
                    .descendant(Locator.tagWithClass("td", "content")
                            .child(Locator.tagWithClass("a", "domain-annotation-item")))
                    .findOptionalElement(this);
        }

        Optional<WebElement> selectedConceptLink()
        {
            return Locator.tagWithClass("table", "domain-annotation-table")
                    .withDescendant(selectConceptBtnLoc)
                    .descendant(Locator.tagWithClass("td", "content")
                            .child(Locator.tagWithClass("a", "domain-annotation-item")))
                    .findOptionalElement(this);
        }

        Optional<WebElement> removeSelectedVocabularyLink()
        {
            return Locator.tagWithClass("table", "domain-annotation-table")
                    .withDescendant(selectVocabularyBtnLoc)
                    .descendant(Locator.tagWithClass("td", "content")
                            .child(Locator.tagWithClass("a", "domain-validator-link")
                                    .child(Locator.tagWithClass("i", "fa-remove"))))
                    .findOptionalElement(this);
        }

        Optional<WebElement> removeSelectedConceptLink()
        {
            return Locator.tagWithClass("table", "domain-annotation-table")
                    .withDescendant(selectConceptBtnLoc)
                    .descendant(Locator.tagWithClass("td", "content")
                            .child(Locator.tagWithClass("a", "domain-validator-link")
                                    .child(Locator.tagWithClass("i", "fa-remove"))))
                    .findOptionalElement(this);
        }


        private Select waitForSelectToLoad(Select select)
        {
            Locator.XPathLocator loadingOption = Locator.tagWithText("option", "Loading...");
            if (!WebDriverWrapper.waitFor(() -> !loadingOption.existsIn(select.getWrappedElement()), WAIT_FOR_JAVASCRIPT))
            {
                throw new NoSuchElementException("Select got stuck loading: " + select.getWrappedElement());
            }
            return select;
        }

        public Checkbox getLookupValidatorEnabledCheckbox()
        {
            return new Checkbox(Locator.checkboxByName("domainpropertiesrow-lookupValidator").findElement(this));
        }

        public WebElement rangeButton()
        {
            return Locator.waitForAnyElement(new FluentWait<SearchContext>(this).withTimeout(Duration.ofMillis(WAIT_FOR_JAVASCRIPT)),
                    Locator.button("Add Range"), Locator.button("Edit Ranges"));
        }

        public WebElement regexValidatorButton()
        {
            return Locator.waitForAnyElement(new FluentWait<SearchContext>(this).withTimeout(Duration.ofMillis(WAIT_FOR_JAVASCRIPT)),
                    Locator.button("Add Regex"), Locator.button("Edit Regex"));
        }

        public WebElement conditionalFormatButton()
        {
            return Locator.waitForAnyElement(new FluentWait<SearchContext>(this).withTimeout(Duration.ofMillis(WAIT_FOR_JAVASCRIPT)),
                    Locator.button("Add Format"), Locator.button("Edit Formats"));
        }

        public Locator hitSelectionCriteriaBtnLoc = Locator.button("Edit Criteria");
        public WebElement hitSelectionCriteriaButton()
        {
            return hitSelectionCriteriaBtnLoc.waitForElement(this, WAIT_FOR_JAVASCRIPT);
        }

        public List<String> hitSelectionCriteria()
        {
            return Locator.tagWithClass("li", "hit-criteria-renderer__field-value")
                    .findElements(this).stream().map(WebElementUtils::getTextContent).toList();
        }

        public RadioButton aliquotOption(ExpSchema.DerivationDataScopeType option)
        {
            return new RadioButton.RadioButtonFinder().withValue(option.name()).find(this);
        }

        public Select attachmentBehavior = SelectWrapper.Select(Locator.tagWithAttribute("select", "name", "domainpropertiesrow-format"))
                .findWhenNeeded(this);

    }
}