Exemplo n.º 1
0
        public DatasetElement GetTerminologyMedDra()
        {
            var meddraElement = _unitOfWork.Repository <DatasetElement>().Queryable().SingleOrDefault(u => u.ElementName == "TerminologyMedDra");

            if (meddraElement == null)
            {
                meddraElement = new DatasetElement()
                {
                    // Prepare new element
                    DatasetElementType = _unitOfWork.Repository <DatasetElementType>().Queryable().Single(x => x.Description == "Generic"),
                    Field = new Field()
                    {
                        Anonymise = false,
                        Mandatory = false,
                        FieldType = _unitOfWork.Repository <FieldType>().Queryable().Single(x => x.Description == "AlphaNumericTextbox")
                    },
                    ElementName  = "TerminologyMedDra",
                    DefaultValue = string.Empty,
                    Oid          = string.Empty,
                    System       = true
                };
                var rule = meddraElement.GetRule(DatasetRuleType.ElementCanoOnlyLinkToSingleDataset);
                rule.RuleActive = true;

                _unitOfWork.Repository <DatasetElement>().Save(meddraElement);
            }
            return(meddraElement);
        }
Exemplo n.º 2
0
        public async Task <IActionResult> CreateDatasetElement(
            [FromBody] DatasetElementForUpdateDto datasetElementForUpdate)
        {
            if (datasetElementForUpdate == null)
            {
                ModelState.AddModelError("Message", "Unable to load payload for new request");
            }

            if (Regex.Matches(datasetElementForUpdate.ElementName, @"[a-zA-Z() ']").Count < datasetElementForUpdate.ElementName.Length)
            {
                ModelState.AddModelError("Message", "Element contains invalid characters (Enter A-Z, a-z, open and Close brackets)");
            }

            if (Regex.Matches(datasetElementForUpdate.OID, @"[-a-zA-Z0-9 ']").Count < datasetElementForUpdate.OID.Length)
            {
                ModelState.AddModelError("Message", "OID contains invalid characters (Enter A-Z, a-z, 0-9, hyphen)");
            }

            if (Regex.Matches(datasetElementForUpdate.DefaultValue, @"[-a-zA-Z0-9 ']").Count < datasetElementForUpdate.DefaultValue.Length)
            {
                ModelState.AddModelError("Message", "Default value contains invalid characters (Enter A-Z, a-z, 0-9, hyphen)");
            }

            if (_unitOfWork.Repository <DatasetElement>().Queryable().
                Where(l => l.ElementName == datasetElementForUpdate.ElementName)
                .Count() > 0)
            {
                ModelState.AddModelError("Message", "Item with same name already exists");
            }

            var fieldType = await _fieldTypeRepository.GetAsync(ft => ft.Description == datasetElementForUpdate.FieldTypeName.ToString());

            if (fieldType == null)
            {
                ModelState.AddModelError("Message", "Unable to locate field type");
            }
            var elementType = await _datasetElementTypeRepository.GetAsync(ft => ft.Description == "Generic");

            if (elementType == null)
            {
                ModelState.AddModelError("Message", "Unable to locate element type");
            }

            long id = 0;

            if (ModelState.IsValid)
            {
                var newDatasetElement = new DatasetElement()
                {
                    DatasetElementType = elementType,
                    ElementName        = datasetElementForUpdate.ElementName,
                    Oid          = datasetElementForUpdate.OID,
                    DefaultValue = datasetElementForUpdate.DefaultValue,
                    Field        = new Field()
                    {
                        Anonymise = (datasetElementForUpdate.Anonymise == Models.ValueTypes.YesNoValueType.Yes),
                        Mandatory = (datasetElementForUpdate.Mandatory == Models.ValueTypes.YesNoValueType.Yes),
                        FieldType = fieldType,
                        MaxLength = datasetElementForUpdate.FieldTypeName == FieldTypes.AlphaNumericTextbox ? datasetElementForUpdate.MaxLength : (short?)null,
                        Decimals  = datasetElementForUpdate.FieldTypeName == FieldTypes.NumericTextbox ? datasetElementForUpdate.Decimals : (short?)null,
                        MinSize   = datasetElementForUpdate.FieldTypeName == FieldTypes.NumericTextbox ? datasetElementForUpdate.MinSize : (decimal?)null,
                        MaxSize   = datasetElementForUpdate.FieldTypeName == FieldTypes.NumericTextbox ? datasetElementForUpdate.MaxSize : (decimal?)null
                    },
                    System = (datasetElementForUpdate.System == Models.ValueTypes.YesNoValueType.Yes)
                };

                var rule = newDatasetElement.GetRule(DatasetRuleType.ElementCanoOnlyLinkToSingleDataset);
                rule.RuleActive = (datasetElementForUpdate.SingleDatasetRule == Models.ValueTypes.YesNoValueType.Yes);

                _datasetElementRepository.Save(newDatasetElement);
                id = newDatasetElement.Id;

                var mappedDatasetElement = await GetDatasetElementAsync <DatasetElementIdentifierDto>(id);

                if (mappedDatasetElement == null)
                {
                    return(StatusCode(500, "Unable to locate newly added item"));
                }

                return(CreatedAtAction("GetDatasetElementByIdentifier",
                                       new
                {
                    id = mappedDatasetElement.Id
                }, CreateLinksForDatasetElement <DatasetElementIdentifierDto>(mappedDatasetElement)));
            }

            return(BadRequest(ModelState));
        }