private void SaveCustomizableFieldValue(CustomizableFieldValue fieldValue, int groupId, bool isInsert)
        {
            string sqlText = @"
                                INSERT INTO [AdvancedFieldsValues] 
                                    ([entity_field_id]
                                    ,[field_id]
                                    ,[value]) 
                                VALUES 
                                    (@entity_field_id
                                    ,@field_id
                                    ,@value)";

            if (!isInsert)
            {
                sqlText = @"UPDATE [AdvancedFieldsValues] 
                            SET [value] = @value
                            WHERE [entity_field_id] = @entity_field_id 
                            AND [field_id] = @field_id";
            }
            using (SqlConnection conn = GetConnection())
                using (OpenCbsCommand insertValue = new OpenCbsCommand(sqlText, conn))
                {
                    insertValue.AddParam("@entity_field_id", groupId);
                    insertValue.AddParam("@field_id", fieldValue.Field.Id);
                    insertValue.AddParam("@value", fieldValue.Value);
                    insertValue.ExecuteNonQuery();
                }
        }
        public List <CustomizableFieldValue> CheckCustomizableFields(OCustomizableFieldEntities entity, CustomClass customFields,
                                                                     CollectionList customizableFieldsCollections, int linkId, char linkType)
        {
            List <CustomizableFieldValue> fieldValues = new List <CustomizableFieldValue>();

            var customizableFieldsServices = ServicesProvider.GetInstance().GetCustomizableFieldsServices();
            List <CustomizableField> customizableFields = customizableFieldsServices.
                                                          SelectCustomizableFields((int)Enum.Parse(typeof(OCustomizableFieldEntities), entity.ToString()));

            if (customizableFields != null)
            {
                foreach (CustomizableField field in customizableFields)
                {
                    CustomizableFieldValue customizableFieldValue = new CustomizableFieldValue {
                        Field = field
                    };

                    var fieldName = field.Name;
                    switch (field.Type)
                    {
                    case OCustomizableFieldTypes.Boolean:
                        customizableFieldValue.Value = ((bool)customFields.GetPropertyValueByName(fieldName)).ToString(CultureInfo.InvariantCulture);
                        break;

                    case OCustomizableFieldTypes.Number:
                        customizableFieldValue.Value = ((string)customFields.GetPropertyValueByName(fieldName));
                        break;

                    case OCustomizableFieldTypes.String:
                        customizableFieldValue.Value = (string)customFields.GetPropertyValueByName(fieldName);
                        break;

                    case OCustomizableFieldTypes.Date:
                        DateTime dateValue = (DateTime)customFields.GetPropertyValueByName(fieldName);
                        customizableFieldValue.Value = Converter.CustomFieldDateToString(dateValue);
                        break;

                    case OCustomizableFieldTypes.Client:
                        customizableFieldValue.Value = customFields.GetPropertyValueByName(fieldName).ToString();
                        break;

                    case OCustomizableFieldTypes.Collection:
                    {
                        int index = customizableFieldsCollections.GetItemIndexByName(fieldName, (string)customFields.GetPropertyValueByName(fieldName));
                        if (index != -1)
                        {
                            customizableFieldValue.Value = index.ToString(CultureInfo.InvariantCulture);
                        }
                    }
                    break;
                    }

                    var fieldType  = field.Type;
                    var fieldValue = customizableFieldValue.Value;
                    if (customizableFieldValue.Field.IsMandatory)
                    {
                        if (
                            (fieldType == OCustomizableFieldTypes.Number && fieldValue == string.Empty) ||
                            (fieldType == OCustomizableFieldTypes.String && fieldValue == string.Empty) ||
                            (fieldType == OCustomizableFieldTypes.Date && Converter.CustomFieldValueToDate(fieldValue) == DateTime.MinValue) ||
                            (fieldType == OCustomizableFieldTypes.Collection && fieldValue == null) ||
                            (fieldType == OCustomizableFieldTypes.Client && fieldValue == string.Empty)
                            )
                        {
                            throw new OpenCbsContractSaveException(OpenCbsContractSaveExceptionEnum.FieldIsMandatory);
                        }
                    }

                    if (fieldType == OCustomizableFieldTypes.Number)
                    {
                        if (fieldValue != string.Empty)
                        {
                            decimal result;
                            if (!Converter.CustomFieldDecimalParse(out result, fieldValue))
                            {
                                throw new OpenCbsContractSaveException(
                                          OpenCbsContractSaveExceptionEnum.NumberFieldIsNotANumber);
                            }
                        }
                    }

                    if (fieldType == OCustomizableFieldTypes.String)
                    {
                        if (fieldValue.Length > 300)
                        {
                            throw new OpenCbsCustomFieldNameException(OCustomFieldExceptionEnum.FieldLimited);
                        }
                    }

                    if (field.IsUnique)
                    {
                        if (
                            fieldType == OCustomizableFieldTypes.Number ||
                            fieldType == OCustomizableFieldTypes.String ||
                            fieldType == OCustomizableFieldTypes.Date ||
                            fieldType == OCustomizableFieldTypes.Client
                            )
                        {
                            if (customizableFieldsServices.FieldValueExists(linkId, linkType, customizableFieldValue.Field.Id, fieldValue))
                            {
                                throw new OpenCbsContractSaveException(OpenCbsContractSaveExceptionEnum.FieldIsNotUnique);
                            }
                        }
                    }

                    fieldValues.Add(customizableFieldValue);
                }
            }
            return(fieldValues);
        }
        private void LoanAdvancedCustomizableFields()
        {
            // fields
            List <CustomizableField> advancedCustomizableFields = ServicesProvider.GetInstance().
                                                                  GetCustomizableFieldsServices().
                                                                  SelectCustomizableFields(
                (int)Enum.Parse(typeof(OCustomizableFieldEntities), _entity.ToString()));

            // values
            List <CustomizableFieldValue> values =
                GetCustomizableFieldsServices().SelectCustomizableFieldValues(_linkId, _entityType);

            if (advancedCustomizableFields != null && advancedCustomizableFields.Count > 0)
            {
                foreach (CustomizableField field in advancedCustomizableFields)
                {
                    CustomProperty         myField          = null;
                    string                 fieldName        = field.Name;
                    CustomizableFieldValue value            = GetValueForField(values, fieldName);
                    string                 fieldDescription = field.Description;
                    switch (field.Type)
                    {
                    case OCustomizableFieldTypes.Boolean:
                        bool boolValue = value != null && bool.Parse(value.Value);
                        myField = new CustomProperty(fieldName, fieldDescription, boolValue, typeof(bool), false, true);
                        break;

                    case OCustomizableFieldTypes.Number:
                        object numberValue = value == null ? string.Empty : value.Value;
                        myField = new CustomProperty(fieldName, fieldDescription, numberValue, typeof(string), false, true);
                        break;

                    case OCustomizableFieldTypes.String:
                        string stringValue = value == null ? string.Empty : value.Value;
                        myField = new CustomProperty(fieldName, fieldDescription, stringValue, typeof(string), false, true);
                        break;

                    case OCustomizableFieldTypes.Date:
                        DateTime dateTime = value == null ? DateTime.Today : Converter.CustomFieldValueToDate(value.Value);
                        myField = new CustomProperty(fieldName, fieldDescription, dateTime, typeof(DateTime), false, true);
                        break;

                    case OCustomizableFieldTypes.Collection:
                        if (value == null)
                        {
                            _advancedFieldsCollections.Add(fieldName, field.Collection);
                            myField = new CustomProperty(fieldName, fieldDescription, string.Empty, typeof(CollectionType), false, true);
                        }
                        else
                        {
                            Collection.Items = value.Field.Collection;
                            if (value.Value != null)
                            {
                                _advancedFieldsCollections.Add(value.Field.Name, value.Field.Collection);
                                myField = new CustomProperty(value.Field.Name, value.Field.Description, Collection.Items[int.Parse(value.Value)],
                                                             typeof(CollectionType), false, true);
                            }
                            else
                            {
                                _advancedFieldsCollections.Add(value.Field.Name, value.Field.Collection);
                                myField = new CustomProperty(value.Field.Name, value.Field.Description, string.Empty, typeof(CollectionType), false, true);
                            }
                        }
                        break;

                    case OCustomizableFieldTypes.Client:
                        CustomClientField clientField;
                        if (value == null || value.Value == string.Empty)
                        {
                            clientField = CustomClientField.Empty;
                        }
                        else
                        {
                            int personId;
                            if (!int.TryParse(value.Value, out personId))
                            {
                                clientField = CustomClientField.Empty;
                            }
                            else
                            {
                                var clientService = ServiceProvider.GetClientServices();
                                var person        = clientService.FindPersonById(personId);
                                clientField = new CustomClientField(person);
                            }
                        }
                        myField = new CustomProperty(fieldName, fieldDescription, clientField, typeof(CustomClientField), false, true);
                        break;
                    }

                    _advancedFields.Add(myField);
                }
            }

            fieldGrid.Refresh();
        }