Example #1
8
        /// <summary>
        /// Create and configure the organization service proxy.
        /// Create few types of attributes.
        /// Insert status in the existing status list.
        /// Retrieve attribute.
        /// Update attribute.
        /// Update existing state value.
        /// Optionally delete/revert any attributes 
        /// that were created/changed for this sample.
         /// </summary>
        /// <param name="serverConfig">Contains server connection information.</param>
        /// <param name="promptForDelete">When True, the user will be prompted to delete all
        /// created entities.</param>
        public void Run(ServerConnection.Configuration serverConfig, bool promptForDelete)
        {
            try
            {

                // Connect to the Organization service. 
                // The using statement assures that the service proxy will be properly disposed.
                using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri,serverConfig.Credentials, serverConfig.DeviceCredentials))
                {
                    // This statement is required to enable early-bound type support.
                    _serviceProxy.EnableProxyTypes();

                    //<snippetWorkWithAttributes1>
                    #region How to create attributes
                    //<snippetWorkWithAttributes2>
                    // Create storage for new attributes being created
                    addedAttributes = new List<AttributeMetadata>();

                    // Create a boolean attribute
                    BooleanAttributeMetadata boolAttribute = new BooleanAttributeMetadata
                    {
                        // Set base properties
                        SchemaName = "new_boolean",
                        DisplayName = new Label("Sample Boolean", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description = new Label("Boolean Attribute", _languageCode),
                        // Set extended properties
                        OptionSet = new BooleanOptionSetMetadata(
                            new OptionMetadata(new Label("True", _languageCode), 1),
                            new OptionMetadata(new Label("False", _languageCode), 0)
                            )
                    };

                    // Add to list
                    addedAttributes.Add(boolAttribute);

                    // Create a date time attribute
                    DateTimeAttributeMetadata dtAttribute = new DateTimeAttributeMetadata
                    {
                        // Set base properties
                        SchemaName = "new_datetime",
                        DisplayName = new Label("Sample DateTime", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description = new Label("DateTime Attribute", _languageCode),
                        // Set extended properties
                        Format = DateTimeFormat.DateOnly,
                        ImeMode = ImeMode.Disabled
                    };

                    // Add to list
                    addedAttributes.Add(dtAttribute);

                    // Create a decimal attribute	
                    DecimalAttributeMetadata decimalAttribute = new DecimalAttributeMetadata
                    {
                        // Set base properties
                        SchemaName = "new_decimal",
                        DisplayName = new Label("Sample Decimal", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description = new Label("Decimal Attribute", _languageCode),
                        // Set extended properties
                        MaxValue = 100,
                        MinValue = 0,
                        Precision = 1
                    };

                    // Add to list
                    addedAttributes.Add(decimalAttribute);

                    // Create a integer attribute	
                    IntegerAttributeMetadata integerAttribute = new IntegerAttributeMetadata
                    {
                        // Set base properties
                        SchemaName = "new_integer",
                        DisplayName = new Label("Sample Integer", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description = new Label("Integer Attribute", _languageCode),
                        // Set extended properties
                        Format = IntegerFormat.None,
                        MaxValue = 100,
                        MinValue = 0
                    };

                    // Add to list
                    addedAttributes.Add(integerAttribute);

                    // Create a memo attribute 
                    MemoAttributeMetadata memoAttribute = new MemoAttributeMetadata
                    {
                        // Set base properties
                        SchemaName = "new_memo",
                        DisplayName = new Label("Sample Memo", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description = new Label("Memo Attribute", _languageCode),
                        // Set extended properties
                        Format = StringFormat.TextArea,
                        ImeMode = ImeMode.Disabled,
                        MaxLength = 500
                    };

                    // Add to list
                    addedAttributes.Add(memoAttribute);

                    // Create a money attribute	
                    MoneyAttributeMetadata moneyAttribute = new MoneyAttributeMetadata
                    {
                        // Set base properties
                        SchemaName = "new_money",
                        DisplayName = new Label("Money Picklist", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description = new Label("Money Attribue", _languageCode),
                        // Set extended properties
                        MaxValue = 1000.00,
                        MinValue = 0.00,
                        Precision = 1,
                        PrecisionSource = 1,
                        ImeMode = ImeMode.Disabled
                    };

                    // Add to list
                    addedAttributes.Add(moneyAttribute);

                    // Create a picklist attribute	
                    PicklistAttributeMetadata pickListAttribute =
                        new PicklistAttributeMetadata
                    {
                        // Set base properties
                        SchemaName = "new_picklist",
                        DisplayName = new Label("Sample Picklist", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description = new Label("Picklist Attribute", _languageCode),
                        // Set extended properties
                        // Build local picklist options
                        OptionSet = new OptionSetMetadata
                            {
                                IsGlobal = false,
                                OptionSetType = OptionSetType.Picklist,
                                Options = 
                            {
                                new OptionMetadata(
                                    new Label("Created", _languageCode), null),
                                new OptionMetadata(
                                    new Label("Updated", _languageCode), null),
                                new OptionMetadata(
                                    new Label("Deleted", _languageCode), null)
                            }
                            }
                    };

                    // Add to list
                    addedAttributes.Add(pickListAttribute);

                    // Create a string attribute
                    StringAttributeMetadata stringAttribute = new StringAttributeMetadata
                    {
                        // Set base properties
                        SchemaName = "new_string",
                        DisplayName = new Label("Sample String", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description = new Label("String Attribute", _languageCode),
                        // Set extended properties
                        MaxLength = 100
                    };

                    // Add to list
                    addedAttributes.Add(stringAttribute);

                    // NOTE: LookupAttributeMetadata cannot be created outside the context of a relationship.
                    // Refer to the WorkWithRelationships.cs reference SDK sample for an example of this attribute type.

                    // NOTE: StateAttributeMetadata and StatusAttributeMetadata cannot be created via the SDK.

                    foreach (AttributeMetadata anAttribute in addedAttributes)
                    {
                        // Create the request.
                        CreateAttributeRequest createAttributeRequest = new CreateAttributeRequest
                        {
                            EntityName = Contact.EntityLogicalName,
                            Attribute = anAttribute
                        };

                        // Execute the request.
                        _serviceProxy.Execute(createAttributeRequest);

                        Console.WriteLine("Created the attribute {0}.", anAttribute.SchemaName);
                    }
                    //</snippetWorkWithAttributes2>
                    #endregion How to create attributes

                    #region How to insert status
                    //<snippetWorkWithAttributes3>
                    // Use InsertStatusValueRequest message to insert a new status 
                    // in an existing status attribute. 
                    // Create the request.
                    InsertStatusValueRequest insertStatusValueRequest =
                        new InsertStatusValueRequest
                    {
                        AttributeLogicalName = "statuscode",
                        EntityLogicalName = Contact.EntityLogicalName,
                        Label = new Label("Dormant", _languageCode),
                        StateCode = 0
                    };

                    // Execute the request and store newly inserted value 
                    // for cleanup, used later part of this sample. 
                    _insertedStatusValue = ((InsertStatusValueResponse)_serviceProxy.Execute(
                        insertStatusValueRequest)).NewOptionValue;

                    Console.WriteLine("Created {0} with the value of {1}.",
                        insertStatusValueRequest.Label.LocalizedLabels[0].Label,
                        _insertedStatusValue);
                    //</snippetWorkWithAttributes3>
                    #endregion How to insert status

                    #region How to retrieve attribute
                    //<snippetWorkWithAttributes4>
                    // Create the request
                    RetrieveAttributeRequest attributeRequest = new RetrieveAttributeRequest
                    {
                        EntityLogicalName = Contact.EntityLogicalName,
                        LogicalName = "new_string",
                        RetrieveAsIfPublished = true
                    };

                    // Execute the request
                    RetrieveAttributeResponse attributeResponse =
                        (RetrieveAttributeResponse)_serviceProxy.Execute(attributeRequest);

                    Console.WriteLine("Retrieved the attribute {0}.",
                        attributeResponse.AttributeMetadata.SchemaName);
                    //</snippetWorkWithAttributes4>
                    #endregion How to retrieve attribute
                    
                    #region How to update attribute
                    //<snippetWorkWithAttributes5>
                    // Modify the retrieved attribute
                    AttributeMetadata retrievedAttributeMetadata =
                        attributeResponse.AttributeMetadata;
                    retrievedAttributeMetadata.DisplayName =
                        new Label("Update String Attribute", _languageCode);

                    // Update an attribute retrieved via RetrieveAttributeRequest
                    UpdateAttributeRequest updateRequest = new UpdateAttributeRequest
                    {
                        Attribute = retrievedAttributeMetadata,
                        EntityName = Contact.EntityLogicalName,
                        MergeLabels = false
                    };

                    // Execute the request
                    _serviceProxy.Execute(updateRequest);

                    Console.WriteLine("Updated the attribute {0}.",
                        retrievedAttributeMetadata.SchemaName);
                    //</snippetWorkWithAttributes5>
                    #endregion How to update attribute

                    #region How to update state value
                    //<snippetWorkWithAttributes6>
                    // Modify the state value label from Active to Open.
                    // Create the request.
                    UpdateStateValueRequest updateStateValue = new UpdateStateValueRequest
                    {
                        AttributeLogicalName = "statecode",
                        EntityLogicalName = Contact.EntityLogicalName,
                        Value = 1,
                        Label = new Label("Open", _languageCode)
                    };

                    // Execute the request.
                    _serviceProxy.Execute(updateStateValue);

                    Console.WriteLine(
                        "Updated {0} state attribute of {1} entity from 'Active' to '{2}'.",
                        updateStateValue.AttributeLogicalName,
                        updateStateValue.EntityLogicalName,
                        updateStateValue.Label.LocalizedLabels[0].Label
                        );
                    //</snippetWorkWithAttributes6>
                    #endregion How to update state value

                    #region How to insert a new option item in a local option set
                    //<snippetWorkWithAttributes7>
                    // Create a request.
                    InsertOptionValueRequest insertOptionValueRequest =
                        new InsertOptionValueRequest
                    {
                        AttributeLogicalName = "new_picklist",
                        EntityLogicalName = Contact.EntityLogicalName,
                        Label = new Label("New Picklist Label", _languageCode)
                    };

                    // Execute the request.
                    int insertOptionValue = ((InsertOptionValueResponse)_serviceProxy.Execute(
                        insertOptionValueRequest)).NewOptionValue;

                    Console.WriteLine("Created {0} with the value of {1}.",
                        insertOptionValueRequest.Label.LocalizedLabels[0].Label,
                        insertOptionValue);
                    //</snippetWorkWithAttributes7>
                    #endregion How to insert a new option item in a local option set

                    #region How to change the order of options of a local option set
                    //<snippetWorkWithAttributes8>
                    // Use the RetrieveAttributeRequest message to retrieve  
                    // a attribute by it's logical name.
                    RetrieveAttributeRequest retrieveAttributeRequest =
                        new RetrieveAttributeRequest
                    {
                        EntityLogicalName = Contact.EntityLogicalName,
                        LogicalName = "new_picklist",
                        RetrieveAsIfPublished = true
                    };

                    // Execute the request.
                    RetrieveAttributeResponse retrieveAttributeResponse =
                        (RetrieveAttributeResponse)_serviceProxy.Execute(
                        retrieveAttributeRequest);

                    // Access the retrieved attribute.
                    PicklistAttributeMetadata retrievedPicklistAttributeMetadata =
                        (PicklistAttributeMetadata)
                        retrieveAttributeResponse.AttributeMetadata;

                    // Get the current options list for the retrieved attribute.
                    OptionMetadata[] optionList =
                        retrievedPicklistAttributeMetadata.OptionSet.Options.ToArray();

                    // Change the order of the original option's list.
                    // Use the OrderBy (OrderByDescending) linq function to sort options in  
                    // ascending (descending) order according to label text.
                    // For ascending order use this:
                    var updateOptionList =
                        optionList.OrderBy(x => x.Label.LocalizedLabels[0].Label).ToList();

                    // For descending order use this:
                    // var updateOptionList =
                    //      optionList.OrderByDescending(
                    //      x => x.Label.LocalizedLabels[0].Label).ToList();

                    // Create the request.
                    OrderOptionRequest orderOptionRequest = new OrderOptionRequest
                    {
                        // Set the properties for the request.
                        AttributeLogicalName = "new_picklist",
                        EntityLogicalName = Contact.EntityLogicalName,
                        // Set the changed order using Select linq function 
                        // to get only values in an array from the changed option list.
                        Values = updateOptionList.Select(x => x.Value.Value).ToArray()
                    };

                    // Execute the request
                    _serviceProxy.Execute(orderOptionRequest);

                    Console.WriteLine("Option Set option order changed");
                    //</snippetWorkWithAttributes8>
                    #endregion How to change the order of options of a global option set

                    // NOTE: All customizations must be published before they can be used.
                    _serviceProxy.Execute(new PublishAllXmlRequest());
                    Console.WriteLine("Published all customizations.");
                    //</snippetWorkWithAttributes1>

                    DeleteRequiredRecords(promptForDelete);
                }
            }

            // Catch any service fault exceptions that Microsoft Dynamics CRM throws.
            catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault>)
            {
                // You can handle an exception here or pass it back to the calling method.
                throw;
            }
        }
Example #2
0
        public void GenerateAttributeAttributeOf()
        {
            var entityMetadata = new EntityMetadata {
                LogicalName = "ee_test", MetadataId = Guid.NewGuid(), DisplayName = new Label("Test", 1033)
            };
            var decimalAttributeMetadata = new DecimalAttributeMetadata
            {
                LogicalName = "ee_testdecimal",
                MetadataId  = Guid.NewGuid(),
                DisplayName = new Label("Dec", 1033)
            }.Set(x => x.EntityLogicalName, entityMetadata.LogicalName).Set(x => x.AttributeOf, "ee_blah");

            organizationMetadata.Entities.Returns(new[] {
                entityMetadata.Set(x => x.Attributes, new AttributeMetadata [] { decimalAttributeMetadata })
            });

            var f = Builder.Create <SolutionComponent>();

            f.Set(x => x.Regarding, entityMetadata.MetadataId);

            SolutionHelper.organisationService.RetrieveMultiple(Arg.Any <QueryExpression>())
            .Returns(new EntityCollection(new List <Entity> {
                Builder.Create <SolutionComponent>().Set(x => x.Regarding, entityMetadata.MetadataId).Set(x => x.ObjectTypeCode, ComponentType.Entity),
            }));

            Assert.IsFalse(sut.GenerateAttribute(decimalAttributeMetadata, serviceProvider));
        }
        private IEnumerable <string> checkDifferenceDecimalAttribute(DecimalAttributeMetadata originalAttributeMetadata, DecimalAttributeMetadata readAttributeMetadata)
        {
            List <string> attributeToChange = new List <string>();

            if (originalAttributeMetadata.Precision != readAttributeMetadata.Precision)
            {
                originalAttributeMetadata.Precision = readAttributeMetadata.Precision;
                attributeToChange.Add("Precision");
            }
            if (originalAttributeMetadata.MinValue != readAttributeMetadata.MinValue)
            {
                originalAttributeMetadata.MinValue = readAttributeMetadata.MinValue;
                attributeToChange.Add("Min Value");
            }
            if (originalAttributeMetadata.MaxValue != readAttributeMetadata.MaxValue)
            {
                originalAttributeMetadata.MaxValue = readAttributeMetadata.MaxValue;
                attributeToChange.Add("Max Value");
            }
            if (originalAttributeMetadata.ImeMode != readAttributeMetadata.ImeMode)
            {
                originalAttributeMetadata.ImeMode = readAttributeMetadata.ImeMode;
                attributeToChange.Add("ImeMode");
            }
            return(attributeToChange);
        }
Example #4
0
        /// <summary>
        /// Sets the decimal size according to the sql precision and scale arguments.
        /// </summary>
        /// <param name="metadata"></param>
        /// <returns></returns>
        public static bool SetFromSqlPrecisionAndScale(this DecimalAttributeMetadata metadata, int precision, int scale)
        {
            if (precision < scale)
            {
                throw new ArgumentOutOfRangeException("precision must be equal to or greater than scale.");
            }

            if (scale < DecimalAttributeMetadata.MinSupportedPrecision || scale > DecimalAttributeMetadata.MaxSupportedPrecision)
            {
                throw new ArgumentOutOfRangeException("scale is not within min and max crm values.");
            }

            // = 12
            var crmMaxValueLengthWithoutPrecision = Math.Max(Math.Truncate(Math.Abs(DecimalAttributeMetadata.MaxSupportedValue)).ToString().Length, Math.Truncate(Math.Abs(DecimalAttributeMetadata.MinSupportedValue)).ToString().Length);

            if (precision - scale > crmMaxValueLengthWithoutPrecision)
            {
                throw new ArgumentOutOfRangeException("The precision is greater than the maximum value crm will allow.");
            }

            metadata.Precision = scale;

            // need to set appropriate min and max values.
            // If the precision is equal to the max precision allowed, then set min and max values allowed.
            if (precision == crmMaxValueLengthWithoutPrecision)
            {
                metadata.MinValue = (decimal)DecimalAttributeMetadata.MinSupportedValue;
                metadata.MaxValue = (decimal)DecimalAttributeMetadata.MaxSupportedValue;
            }
            else
            {
                // the min value should be a series of 9's to the specified precision and scale.
                var maxNumberBuilder = new StringBuilder();
                for (int i = 0; i < precision - scale; i++)
                {
                    maxNumberBuilder.Append("9");
                }
                if (scale > 0)
                {
                    maxNumberBuilder.Append(".");
                    for (int i = 0; i < scale; i++)
                    {
                        maxNumberBuilder.Append("9");
                    }
                }

                decimal maxD;
                if (!decimal.TryParse(maxNumberBuilder.ToString(), out maxD))
                {
                    throw new FormatException(string.Format("Unable to parse {0} as a decimal.", maxNumberBuilder.ToString()));
                }

                var maxNumber = decimal.Parse(maxNumberBuilder.ToString());
                metadata.MaxValue = maxNumber;
                metadata.MinValue = -maxNumber;
            }

            return(true);
        }
Example #5
0
        /// <summary>
        /// Gets the sql precision for the crm decimal attribute.
        /// </summary>
        /// <param name="metadata"></param>
        /// <returns></returns>
        public static int MaxSupportedSqlPrecision(this DecimalAttributeMetadata metadata)
        {
            // = 12 + max scale of 10 = 22 in total.
            var crmPrecision = Math.Max(Math.Truncate(Math.Abs(DecimalAttributeMetadata.MaxSupportedValue)).ToString().Length, Math.Truncate(Math.Abs(DecimalAttributeMetadata.MinSupportedValue)).ToString().Length);

            //  int crmPrecision = Math.Max(Math.Truncate(DecimalAttributeMetadata.MaxSupportedValue).ToString().Length, Math.Truncate(DecimalAttributeMetadata.MinSupportedValue).ToString().Length);
            return(crmPrecision + DecimalAttributeMetadata.MaxSupportedPrecision);
        }
 private object CopyValueInternal(AttributeMetadata oldAttribute, DecimalAttributeMetadata newAttribute, object value)
 {
     decimal output;
     if (decimal.TryParse(value.ToString(), out output))
     {
         return output;
     }
     Trace("Unable to convert value \"" + value + "\" of type \"" + value.GetType().Name + "\" to Decimal");
     return null;
 }
        private object CopyValueInternal(AttributeMetadata oldAttribute, DecimalAttributeMetadata newAttribute, object value)
        {
            decimal output;

            if (decimal.TryParse(value.ToString(), out output))
            {
                return(output);
            }
            Trace("Unable to convert value \"" + value + "\" of type \"" + value.GetType().Name + "\" to Decimal");
            return(null);
        }
Example #8
0
 private AttributeMetadata CloneAttributes(DecimalAttributeMetadata att)
 {
     return(new DecimalAttributeMetadata
     {
         MaxValue = att.MaxValue,
         MinValue = att.MinValue,
         Precision = att.Precision,
         ImeMode = att.ImeMode,
         FormulaDefinition = att.FormulaDefinition
     });
 }
Example #9
0
        private AttributeMetadata CreateDecimalAttribute(ExcelWorksheet sheet, int rowIndex, int startCell)
        {
            var damd = new DecimalAttributeMetadata
            {
                Precision = sheet.GetValue <int>(rowIndex, startCell),
                MinValue  = sheet.GetValue <decimal>(rowIndex, startCell + 1),
                MaxValue  = sheet.GetValue <decimal>(rowIndex, startCell + 2)
            };

            return(damd);
        }
        public void HandleObfuscation(Entity entity, FieldToBeObfuscated field, IEntityMetadataCache metaData)
        {
            entity.ThrowArgumentNullExceptionIfNull(nameof(entity));
            field.ThrowArgumentNullExceptionIfNull(nameof(field));
            metaData.ThrowArgumentNullExceptionIfNull(nameof(metaData));

            DecimalAttributeMetadata decimalMetaData = (DecimalAttributeMetadata)metaData.GetAttribute(entity.LogicalName, field.FieldName);
            int min = (int)decimalMetaData.MinValue.GetValueOrDefault(0);
            int max = (int)decimalMetaData.MaxValue.GetValueOrDefault(10);

            entity[field.FieldName] = decimalScramblerClient.ExecuteScramble((decimal)entity[field.FieldName], min, max);
        }
        private object CopyValueInternal(AttributeMetadata oldAttribute, DecimalAttributeMetadata newAttribute, object value, Dictionary <string, string> migrationMapping)
        {
            var copy = value.ToString();

            copy = migrationMapping.TryGetValue(copy, out var mappedValue) ? mappedValue : copy;
            if (decimal.TryParse(copy, out var output))
            {
                return(output);
            }
            Trace("Unable to convert value \"" + value + "\" of type \"" + value.GetType().Name + "\" to Decimal");
            return(null);
        }
        private AttributeMetadata decimalFieldCreation(string[] row)
        {
            DecimalAttributeMetadata attrMetadata = new DecimalAttributeMetadata(Utils.addOrgPrefix(row[ExcelColumsDefinition.SCHEMANAMEEXCELCOL], organizationPrefix, currentOperationCreate));

            generalFieldCreation(row, attrMetadata);
            int     parseResult;
            decimal decimalResult;

            attrMetadata.MaxValue  = decimal.TryParse(row[ExcelColumsDefinition.DECIMALMAXVALUE], out decimalResult) ? decimalResult : (decimal?)null;
            attrMetadata.MinValue  = decimal.TryParse(row[ExcelColumsDefinition.DECIMALMINVALUE], out decimalResult) ? decimalResult : (decimal?)null;
            attrMetadata.Precision = int.TryParse(row[ExcelColumsDefinition.DECIMALPRECISION], out parseResult) ? parseResult : (int?)null;
            string imeModeFormatString = row[ExcelColumsDefinition.DECIMALIMEMODE];

            attrMetadata.ImeMode = Enum.IsDefined(typeof(ImeMode), imeModeFormatString) ? (ImeMode)Enum.Parse(typeof(ImeMode), imeModeFormatString, true) : (ImeMode?)null;
            return(attrMetadata);
        }
Example #13
0
        private AttributeMetadata CreateDecimalAttribute(object[] dataRowValues)
        {
            var metadata = new DecimalAttributeMetadata
            {
                Precision = 2,
                MinValue  = (decimal)DecimalAttributeMetadata.MinSupportedValue,
                MaxValue  = (decimal)DecimalAttributeMetadata.MaxSupportedValue,
                ImeMode   = ImeMode.Auto
            };

            foreach (var column in Columns)
            {
                var value = dataRowValues[column.Position - 1];
                var field = (ConfigurationFile.AttributeFields)column.TargetField;

                if (value != null && !string.IsNullOrEmpty(value as string))
                {
                    switch (field)
                    {
                    case ConfigurationFile.AttributeFields.Precision:
                        var precision = (int)value;
                        if (precision >= DecimalAttributeMetadata.MinSupportedPrecision && precision <= DecimalAttributeMetadata.MaxSupportedPrecision)
                        {
                            metadata.Precision = precision;
                        }
                        break;

                    case ConfigurationFile.AttributeFields.MinimumValue:
                        metadata.MinValue = (decimal)value;
                        break;

                    case ConfigurationFile.AttributeFields.MaximumValue:
                        metadata.MaxValue = (decimal)value;
                        break;

                    case ConfigurationFile.AttributeFields.ImeMode:
                        metadata.ImeMode = (ImeMode)EnumUtils.GetSelectedOption(field, value);
                        break;
                    }
                }
                else if (!EnumUtils.IsOptional(field))
                {
                    throw new ArgumentException($"Mandatory data field {EnumUtils.Label(field)} does not contain a value.");
                }
            }
            return(metadata);
        }
        public DecimalAttributeMetadata CreateQuantityDecimal(string schema, string label, int lang, AttributeRequiredLevel requiredLevel, decimal maxValue, decimal minValue, int precisionSize)
        {
            DecimalAttributeMetadata decimalAttribute = new DecimalAttributeMetadata
            {
                // Set base properties
                SchemaName    = schema,
                DisplayName   = new Label(label, lang),
                RequiredLevel = new AttributeRequiredLevelManagedProperty(requiredLevel),
                Description   = new Label(label, lang),
                // Set extended properties
                MaxValue  = maxValue,     //100,
                MinValue  = minValue,     //0,
                Precision = precisionSize //3
            };

            return(decimalAttribute);
        }
Example #15
0
        /// <summary>
        /// Procedure: CreateDecimal
        /// Handles:
        /// Created By: Will Wilson
        /// Created Date: 01/01/2016
        /// Changes By:
        /// Changes Date:
        /// Changes Made:
        /// </summary>
        static DecimalAttributeMetadata CreateDecimal(string schema, string label, int lang, AttributeRequiredLevel requiredLevel)
        {
            DecimalAttributeMetadata decimalAttribute = new DecimalAttributeMetadata
            {
                // Set base properties
                SchemaName    = schema,
                DisplayName   = new Label(label, lang),
                RequiredLevel = new AttributeRequiredLevelManagedProperty(requiredLevel),
                Description   = new Label(label, lang),
                // Set extended properties
                MaxValue  = 100,
                MinValue  = 0,
                Precision = 1
            };

            return(decimalAttribute);
        }
        private DecimalAttributeMetadata BuildCreateDecimalAttribute()
        {
            var decimalMetadata = new DecimalAttributeMetadata();
            int precision       = decimalMetadata.DefaultSqlPrecision();
            int scale           = decimalMetadata.DefaultSqlScale();
            var dataType        = this.CurrentColumnDefinition.DataType;

            if (dataType.Arguments != null && dataType.Arguments.Any())
            {
                // first is scale, second is precision.
                var argsCount = dataType.Arguments.Count();
                if (argsCount > 2)
                {
                    throw new InvalidOperationException("Datatype can have a maximum of 2 size arguments.");
                }

                if (argsCount >= 1)
                {
                    var sqlPrecisionArg = dataType.Arguments.First();
                    ((IVisitableBuilder)sqlPrecisionArg).Accept(this);
                    if (CurrentNumericLiteralValue != null)
                    {
                        precision = Convert.ToInt32(CurrentNumericLiteralValue);
                        CurrentNumericLiteralValue = null;
                    }
                }

                if (argsCount >= 2)
                {
                    int?sqlScale    = null;
                    var sqlScaleArg = dataType.Arguments.Skip(1).Take(1).Single();
                    ((IVisitableBuilder)sqlScaleArg).Accept(this);
                    if (CurrentNumericLiteralValue != null)
                    {
                        sqlScale = Convert.ToInt32(CurrentNumericLiteralValue);
                        CurrentNumericLiteralValue = null;
                    }
                    scale = sqlScale.Value;
                }
            }

            decimalMetadata.SetFromSqlPrecisionAndScale(precision, scale);
            return(decimalMetadata);
        }
Example #17
0
        public DecimalAttributeMetadata Create(AttributeMetadata baseMetadata, int?maxvalue, int?minvalue, int?precision)
        {
            // Create a decimal attribute
            var decimalAttribute = new DecimalAttributeMetadata
            {
                // Set base properties
                SchemaName    = baseMetadata.SchemaName,
                DisplayName   = baseMetadata.DisplayName,
                RequiredLevel = baseMetadata.RequiredLevel,
                Description   = baseMetadata.Description,

                // Set extended properties
                MaxValue  = maxvalue,
                MinValue  = minvalue,
                Precision = precision
            };

            return(decimalAttribute);
        }
Example #18
0
        private static DecimalAttributeMetadata CreateDecimalAttributeMetadata(string name, string displayName, AttributeRequiredLevel attributeRequiredLevel, string desription, int minValue, int maxValue, int precision)
        {
            // Create a date time attribute
            DecimalAttributeMetadata decimalAttribute = new DecimalAttributeMetadata
            {
                // Set base properties
                SchemaName    = publisherPrefix + name,
                LogicalName   = publisherPrefix + name,
                DisplayName   = new Label(displayName, _languageCode),
                RequiredLevel = new AttributeRequiredLevelManagedProperty(attributeRequiredLevel),
                Description   = new Label(desription, _languageCode),
                // Set extended properties
                MaxValue  = maxValue,
                MinValue  = minValue,
                Precision = precision
            };

            return(decimalAttribute);
        }
Example #19
0
        /// <summary>
        /// Gets the sql precision for the crm decimal attribute.
        /// </summary>
        /// <param name="metadata"></param>
        /// <returns></returns>
        public static bool IsSqlPrecisionSupported(this DecimalAttributeMetadata metadata, int precision, int scale)
        {
            if (precision < scale)
            {
                throw new ArgumentOutOfRangeException("precision must be equal to or greater than scale.");
            }

            if (scale < DecimalAttributeMetadata.MinSupportedPrecision || scale > DecimalAttributeMetadata.MaxSupportedPrecision)
            {
                return(false);
            }

            // = 12
            int crmMaxValueLengthWithoutPrecision = Math.Max(DecimalAttributeMetadata.MinSupportedValue.ToString().Length, DecimalAttributeMetadata.MaxSupportedValue.ToString().Length);

            if (precision - scale > crmMaxValueLengthWithoutPrecision)
            {
                return(false);
            }
            return(true);
        }
Example #20
0
        public EntityAttributeMetadataBuilder DecimalAttribute(string schemaName, string displayName, string description, AttributeRequiredLevel requiredLevel, decimal?min, decimal?max, int?precision)
        {
            // Define the primary attribute for the entity
            // Create a integer attribute
            int languageCode = 1033;
            var att          = new DecimalAttributeMetadata()
            {
                // Set base properties
                SchemaName    = schemaName,
                DisplayName   = new Label(schemaName, languageCode),
                RequiredLevel = new AttributeRequiredLevelManagedProperty(requiredLevel),
                Description   = new Label(description, languageCode),
                // Set extended properties
                Precision = precision,
                MaxValue  = max,
                MinValue  = min
            };

            this.Attributes.Add(att);
            return(this);
        }
Example #21
0
        protected override void ExecuteCmdlet()
        {
            base.ExecuteCmdlet();

            DecimalAttributeMetadata attribute = new DecimalAttributeMetadata
            {
                ImeMode = ImeMode.Auto
            };

            if (ImeType == CrmImeType.Active)
            {
                attribute.ImeMode = ImeMode.Active;
            }
            if (ImeType == CrmImeType.Disabled)
            {
                attribute.ImeMode = ImeMode.Disabled;
            }
            if (ImeType == CrmImeType.Inactive)
            {
                attribute.ImeMode = ImeMode.Inactive;
            }

            if (MaxValue.HasValue)
            {
                attribute.MaxValue = MaxValue.Value;
            }
            if (MinValue.HasValue)
            {
                attribute.MinValue = MinValue.Value;
            }
            if (Precision.HasValue)
            {
                attribute.Precision = Precision.Value;
            }

            WriteAttribute(attribute);
        }
        [STAThread] // Required to support the interactive login experience
        static void Main(string[] args)
        {
            CrmServiceClient service = null;

            try
            {
                service = SampleHelpers.Connect("Connect");
                if (service.IsReady)
                {
                    // Create any entity records that the demonstration code requires
                    SetUpSample(service);
                    #region Demonstrate

                    _productVersion = Version.Parse(((RetrieveVersionResponse)service.Execute(new RetrieveVersionRequest())).Version);

                    #region How to create attributes
                    // Create storage for new attributes being created
                    addedAttributes = new List <AttributeMetadata>();

                    // Create a boolean attribute
                    var boolAttribute = new BooleanAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_Boolean",
                        LogicalName   = "new_boolean",
                        DisplayName   = new Label("Sample Boolean", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("Boolean Attribute", _languageCode),
                        // Set extended properties
                        OptionSet = new BooleanOptionSetMetadata(
                            new OptionMetadata(new Label("True", _languageCode), 1),
                            new OptionMetadata(new Label("False", _languageCode), 0)
                            )
                    };

                    // Add to list
                    addedAttributes.Add(boolAttribute);

                    // Create a date time attribute
                    var dtAttribute = new DateTimeAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_Datetime",
                        LogicalName   = "new_datetime",
                        DisplayName   = new Label("Sample DateTime", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("DateTime Attribute", _languageCode),
                        // Set extended properties
                        Format  = DateTimeFormat.DateOnly,
                        ImeMode = ImeMode.Disabled
                    };

                    // Add to list
                    addedAttributes.Add(dtAttribute);

                    // Create a decimal attribute
                    var decimalAttribute = new DecimalAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_Decimal",
                        LogicalName   = "new_decimal",
                        DisplayName   = new Label("Sample Decimal", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("Decimal Attribute", _languageCode),
                        // Set extended properties
                        MaxValue  = 100,
                        MinValue  = 0,
                        Precision = 1
                    };

                    // Add to list
                    addedAttributes.Add(decimalAttribute);

                    // Create a integer attribute
                    var integerAttribute = new IntegerAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_Integer",
                        LogicalName   = "new_integer",
                        DisplayName   = new Label("Sample Integer", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("Integer Attribute", _languageCode),
                        // Set extended properties
                        Format   = IntegerFormat.None,
                        MaxValue = 100,
                        MinValue = 0
                    };

                    // Add to list
                    addedAttributes.Add(integerAttribute);

                    // Create a memo attribute
                    var memoAttribute = new MemoAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_Memo",
                        LogicalName   = "new_memo",
                        DisplayName   = new Label("Sample Memo", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("Memo Attribute", _languageCode),
                        // Set extended properties
                        Format    = StringFormat.TextArea,
                        ImeMode   = ImeMode.Disabled,
                        MaxLength = 500
                    };

                    // Add to list
                    addedAttributes.Add(memoAttribute);

                    // Create a money attribute
                    var moneyAttribute = new MoneyAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_Money",
                        LogicalName   = "new_money",
                        DisplayName   = new Label("Money Picklist", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("Money Attribue", _languageCode),
                        // Set extended properties
                        MaxValue        = 1000.00,
                        MinValue        = 0.00,
                        Precision       = 1,
                        PrecisionSource = 1,
                        ImeMode         = ImeMode.Disabled
                    };

                    // Add to list
                    addedAttributes.Add(moneyAttribute);

                    // Create a picklist attribute
                    var pickListAttribute =
                        new PicklistAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_Picklist",
                        LogicalName   = "new_picklist",
                        DisplayName   = new Label("Sample Picklist", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("Picklist Attribute", _languageCode),
                        // Set extended properties
                        // Build local picklist options
                        OptionSet = new OptionSetMetadata
                        {
                            IsGlobal      = false,
                            OptionSetType = OptionSetType.Picklist,
                            Options       =
                            {
                                new OptionMetadata(
                                    new Label("Created",                        _languageCode), null),
                                new OptionMetadata(
                                    new Label("Updated",                        _languageCode), null),
                                new OptionMetadata(
                                    new Label("Deleted",                        _languageCode), null)
                            }
                        }
                    };

                    // Add to list
                    addedAttributes.Add(pickListAttribute);

                    // Create a string attribute
                    var stringAttribute = new StringAttributeMetadata
                    {
                        // Set base properties
                        SchemaName  = "new_String",
                        LogicalName = "new_string",

                        DisplayName   = new Label("Sample String", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("String Attribute", _languageCode),
                        // Set extended properties
                        MaxLength = 100
                    };

                    // Add to list
                    addedAttributes.Add(stringAttribute);

                    //Multi-select attribute requires version 9.0 or higher.
                    if (_productVersion > new Version("9.0"))
                    {
                        // Create a multi-select optionset
                        var multiSelectOptionSetAttribute = new MultiSelectPicklistAttributeMetadata()
                        {
                            SchemaName    = "new_MultiSelectOptionSet",
                            LogicalName   = "new_multiselectoptionset",
                            DisplayName   = new Label("Multi-Select OptionSet", _languageCode),
                            RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                            Description   = new Label("Multi-Select OptionSet description", _languageCode),
                            OptionSet     = new OptionSetMetadata()
                            {
                                IsGlobal      = false,
                                OptionSetType = OptionSetType.Picklist,
                                Options       =
                                {
                                    new OptionMetadata(new Label("First Option",  _languageCode), null),
                                    new OptionMetadata(new Label("Second Option", _languageCode), null),
                                    new OptionMetadata(new Label("Third Option",  _languageCode), null)
                                }
                            }
                        };
                        // Add to list
                        addedAttributes.Add(multiSelectOptionSetAttribute);
                    }

                    // NOTE: LookupAttributeMetadata cannot be created outside the context of a relationship.
                    // Refer to the WorkWithRelationships.cs reference SDK sample for an example of this attribute type.

                    // NOTE: StateAttributeMetadata and StatusAttributeMetadata cannot be created via the SDK.

                    foreach (AttributeMetadata anAttribute in addedAttributes)
                    {
                        // Create the request.
                        var createAttributeRequest = new CreateAttributeRequest
                        {
                            EntityName = Contact.EntityLogicalName,
                            Attribute  = anAttribute
                        };

                        // Execute the request.
                        service.Execute(createAttributeRequest);

                        Console.WriteLine("Created the attribute {0}.", anAttribute.SchemaName);
                    }
                    #endregion How to create attributes

                    #region How to insert status
                    // Use InsertStatusValueRequest message to insert a new status
                    // in an existing status attribute.
                    // Create the request.
                    var insertStatusValueRequest =
                        new InsertStatusValueRequest
                    {
                        AttributeLogicalName = "statuscode",
                        EntityLogicalName    = Contact.EntityLogicalName,
                        Label     = new Label("Dormant", _languageCode),
                        StateCode = 0
                    };

                    // Execute the request and store newly inserted value
                    // for cleanup, used later part of this sample.
                    _insertedStatusValue = ((InsertStatusValueResponse)service.Execute(
                                                insertStatusValueRequest)).NewOptionValue;

                    Console.WriteLine("Created status named '{0}' with the value of {1}.",
                                      insertStatusValueRequest.Label.LocalizedLabels[0].Label,
                                      _insertedStatusValue);
                    #endregion How to insert status

                    #region How to retrieve attribute
                    // Create the request
                    var attributeRequest = new RetrieveAttributeRequest
                    {
                        EntityLogicalName     = Contact.EntityLogicalName,
                        LogicalName           = "new_string",
                        RetrieveAsIfPublished = true
                    };

                    // Execute the request
                    RetrieveAttributeResponse attributeResponse =
                        (RetrieveAttributeResponse)service.Execute(attributeRequest);

                    Console.WriteLine("Retrieved the attribute {0}.",
                                      attributeResponse.AttributeMetadata.SchemaName);
                    #endregion How to retrieve attribute

                    #region How to update attribute
                    // Modify the retrieved attribute
                    var retrievedAttributeMetadata =
                        attributeResponse.AttributeMetadata;
                    retrievedAttributeMetadata.DisplayName =
                        new Label("Update String Attribute", _languageCode);

                    // Update an attribute retrieved via RetrieveAttributeRequest
                    var updateRequest = new UpdateAttributeRequest
                    {
                        Attribute   = retrievedAttributeMetadata,
                        EntityName  = Contact.EntityLogicalName,
                        MergeLabels = false
                    };

                    // Execute the request
                    service.Execute(updateRequest);

                    Console.WriteLine("Updated the attribute {0}.",
                                      retrievedAttributeMetadata.SchemaName);
                    #endregion How to update attribute

                    #region How to update state value
                    // Modify the state value label from Active to Open.
                    // Create the request.
                    var updateStateValue = new UpdateStateValueRequest
                    {
                        AttributeLogicalName = "statecode",
                        EntityLogicalName    = Contact.EntityLogicalName,
                        Value = 1,
                        Label = new Label("Open", _languageCode)
                    };

                    // Execute the request.
                    service.Execute(updateStateValue);

                    Console.WriteLine(
                        "Updated {0} state attribute of {1} entity from 'Active' to '{2}'.",
                        updateStateValue.AttributeLogicalName,
                        updateStateValue.EntityLogicalName,
                        updateStateValue.Label.LocalizedLabels[0].Label
                        );
                    #endregion How to update state value

                    #region How to insert a new option item in a local option set
                    // Create a request.
                    var insertOptionValueRequest =
                        new InsertOptionValueRequest
                    {
                        AttributeLogicalName = "new_picklist",
                        EntityLogicalName    = Contact.EntityLogicalName,
                        Label = new Label("New Picklist Label", _languageCode)
                    };

                    // Execute the request.
                    int insertOptionValue = ((InsertOptionValueResponse)service.Execute(
                                                 insertOptionValueRequest)).NewOptionValue;

                    Console.WriteLine("Created {0} with the value of {1}.",
                                      insertOptionValueRequest.Label.LocalizedLabels[0].Label,
                                      insertOptionValue);
                    #endregion How to insert a new option item in a local option set

                    #region How to change the order of options of a local option set
                    // Use the RetrieveAttributeRequest message to retrieve
                    // a attribute by it's logical name.
                    var retrieveAttributeRequest =
                        new RetrieveAttributeRequest
                    {
                        EntityLogicalName     = Contact.EntityLogicalName,
                        LogicalName           = "new_picklist",
                        RetrieveAsIfPublished = true
                    };

                    // Execute the request.
                    RetrieveAttributeResponse retrieveAttributeResponse =
                        (RetrieveAttributeResponse)service.Execute(
                            retrieveAttributeRequest);

                    // Access the retrieved attribute.
                    var retrievedPicklistAttributeMetadata =
                        (PicklistAttributeMetadata)
                        retrieveAttributeResponse.AttributeMetadata;

                    // Get the current options list for the retrieved attribute.
                    OptionMetadata[] optionList =
                        retrievedPicklistAttributeMetadata.OptionSet.Options.ToArray();

                    // Change the order of the original option's list.
                    // Use the OrderBy (OrderByDescending) linq function to sort options in
                    // ascending (descending) order according to label text.
                    // For ascending order use this:
                    var updateOptionList =
                        optionList.OrderBy(x => x.Label.LocalizedLabels[0].Label).ToList();

                    // For descending order use this:
                    // var updateOptionList =
                    //      optionList.OrderByDescending(
                    //      x => x.Label.LocalizedLabels[0].Label).ToList();

                    // Create the request.
                    var orderOptionRequest = new OrderOptionRequest
                    {
                        // Set the properties for the request.
                        AttributeLogicalName = "new_picklist",
                        EntityLogicalName    = Contact.EntityLogicalName,
                        // Set the changed order using Select linq function
                        // to get only values in an array from the changed option list.
                        Values = updateOptionList.Select(x => x.Value.Value).ToArray()
                    };

                    // Execute the request
                    service.Execute(orderOptionRequest);

                    Console.WriteLine("Option Set option order changed");
                    #endregion How to change the order of options of a global option set

                    // NOTE: All customizations must be published before they can be used.
                    service.Execute(new PublishAllXmlRequest());
                    Console.WriteLine("Published all customizations.");
                    #endregion Demonstrate

                    #region Clean up
                    CleanUpSample(service);
                    #endregion Clean up
                }
                else
                {
                    const string UNABLE_TO_LOGIN_ERROR = "Unable to Login to Microsoft Dataverse";
                    if (service.LastCrmError.Equals(UNABLE_TO_LOGIN_ERROR))
                    {
                        Console.WriteLine("Check the connection string values in cds/App.config.");
                        throw new Exception(service.LastCrmError);
                    }
                    else
                    {
                        throw service.LastCrmException;
                    }
                }
            }
            catch (Exception ex)
            {
                SampleHelpers.HandleException(ex);
            }

            finally
            {
                if (service != null)
                {
                    service.Dispose();
                }

                Console.WriteLine("Press <Enter> to exit.");
                Console.ReadLine();
            }
        }
 private static UpdateFormulaResponse UpdateInternal(DecimalAttributeMetadata  att, AttributeMetadata from, AttributeMetadata to) { return UpdateForumlaDefinition(att, from, to); }
Example #24
0
        private AttributeMetadata GetAttributeMetadata(string type, string logicalname, string displayname, AttributeRequiredLevel requiredlevel)
        {
            AttributeMetadata attribute = null;

            if (type != null)
            {
                switch (type.ToLower())
                {
                case "boolean":
                    attribute = new BooleanAttributeMetadata
                    {
                        // Set extended properties
                        OptionSet = new BooleanOptionSetMetadata(
                            new OptionMetadata(new Label("True", languageCode), 1),
                            new OptionMetadata(new Label("False", languageCode), 0)
                            )
                    };
                    break;

                case "datetime":
                    // Create a date time attribute
                    attribute = new DateTimeAttributeMetadata
                    {
                        // Set extended properties
                        Format  = DateTimeFormat.DateOnly,
                        ImeMode = ImeMode.Disabled
                    };
                    break;

                case "double":
                    // Create a decimal attribute
                    attribute = new DecimalAttributeMetadata
                    {
                        // Set extended properties
                        MaxValue  = 100,
                        MinValue  = 0,
                        Precision = 1
                    };
                    break;

                case "integer":
                    // Create a integer attribute
                    attribute = new IntegerAttributeMetadata
                    {
                        // Set extended properties
                        Format   = IntegerFormat.None,
                        MaxValue = 100,
                        MinValue = 0
                    };
                    break;

                case "memo":
                    // Create a memo attribute
                    attribute = new MemoAttributeMetadata
                    {
                        // Set extended properties
                        Format    = StringFormat.TextArea,
                        ImeMode   = ImeMode.Disabled,
                        MaxLength = 500
                    };
                    break;

                case "money":
                    // Create a money attribute
                    MoneyAttributeMetadata moneyAttribute = new MoneyAttributeMetadata
                    {
                        // Set extended properties
                        MaxValue        = 1000.00,
                        MinValue        = 0.00,
                        Precision       = 1,
                        PrecisionSource = 1,
                        ImeMode         = ImeMode.Disabled
                    };
                    break;

                case "picklist":
                    // Create a picklist attribute
                    attribute = new PicklistAttributeMetadata
                    {
                        // Set extended properties
                        // Build local picklist options
                        OptionSet = new OptionSetMetadata
                        {
                            IsGlobal      = false,
                            OptionSetType = OptionSetType.Picklist
                        }
                    };
                    break;

                case "string":
                    // Create a string attribute
                    attribute = new StringAttributeMetadata
                    {
                        // Set extended properties
                        MaxLength = 100
                    };
                    break;

                default:
                    throw new ArgumentException(string.Format("Unexpected attribute type: {0}", type));
                }

                // Set base properties
                attribute.SchemaName    = logicalname;
                attribute.DisplayName   = new Label(displayname, languageCode);
                attribute.RequiredLevel = new AttributeRequiredLevelManagedProperty(requiredlevel);
            }

            return(attribute);
        }
        public void CreateCRMAttribute(DataRow record)
        {
            string result = string.Empty;

            try
            {
                #region # Read From Datatable #
                AttributeMetadata createMetadata = new AttributeMetadata();
                bool isGlobal = false;
                AttributeRequiredLevel requirementLevel = AttributeRequiredLevel.None;
                string reqLevelText      = "";
                int    precisionSource   = 0;
                int    currencyPrecision = 2;
                if (record["RequiredLevel"] != null && !string.IsNullOrEmpty(Convert.ToString(record["RequiredLevel"])))
                {
                    reqLevelText     = Convert.ToString(record["RequiredLevel"]).ToLower();
                    requirementLevel = reqLevelText == "required" ? AttributeRequiredLevel.ApplicationRequired : AttributeRequiredLevel.Recommended;
                }
                reqLevelText = record["Attribute Type"].ToString().ToLower();
                string attributeSchemaName  = record["Attribute Schema Name"].ToString().ToLower();
                string optionSetValues      = record["Option Set Values"].ToString().ToLower();
                string attributeDisplayName = record["Attribute Display Name"].ToString().ToLower();
                string attributeDiscription = record["Description"].ToString().ToLower();
                bool   boolDefaultValue     = record["Default  Value"].ToString().ToLower() == "yes"?true:false;

                Microsoft.Xrm.Sdk.Metadata.StringFormat stringFormat = GetStringFormat(record["String Format"].ToString().ToLower());
                int stringLength = record["String Length"] != null && !string.IsNullOrEmpty(Convert.ToString(record["String Length"])) && Convert.ToInt32(record["String Length"].ToString()) <= 4000? Convert.ToInt32(record["String Length"].ToString()) : 4000;

                Microsoft.Xrm.Sdk.Metadata.DateTimeFormat dateFormat   = record["Date Type Format"] != null && !string.IsNullOrEmpty(record["Date Type Format"].ToString()) ? GetDateFormat(record["Date Type Format"].ToString().ToLower()):DateTimeFormat.DateAndTime;
                Microsoft.Xrm.Sdk.Metadata.IntegerFormat  integerFormt = record["Integer Format"] != null && !string.IsNullOrEmpty(record["Integer Format"].ToString()) ? GetIntegerFormat(record["Integer Format"].ToString().ToLower()) : IntegerFormat.None;

                Double intMinValue = record["Integer Minimum Value"] != null && !string.IsNullOrEmpty(Convert.ToString(record["Integer Minimum Value"])) && Convert.ToDouble(record["Integer Minimum Value"].ToString()) <= 2147483647 && Convert.ToDouble(record["Integer Minimum Value"].ToString()) >= -2147483647 ? Convert.ToDouble(record["Integer Minimum Value"].ToString()) : -2147483648;
                Double intMaxValue = record["Integer Maximum Value"] != null && !string.IsNullOrEmpty(Convert.ToString(record["Integer Maximum Value"])) && Convert.ToDouble(record["Integer Maximum Value"].ToString()) <= 2147483647 && Convert.ToDouble(record["Integer Maximum Value"].ToString()) >= -2147483647 ? Convert.ToDouble(record["Integer Maximum Value"].ToString()) : 2147483647;

                int    floatingPrecision = record["Floating Number Precision"] != null && !string.IsNullOrEmpty(Convert.ToString(record["Floating Number Precision"])) ? Convert.ToInt32(record["Floating Number Precision"].ToString()) : 2;
                Double floatMinValue     = record["Float Min Value"] != null && !string.IsNullOrEmpty(Convert.ToString(record["Float Min Value"])) && Convert.ToDouble(record["Float Min Value"].ToString()) >= 0 && Convert.ToDouble(record["Float Min Value"].ToString()) <= 1000000000 ? Convert.ToDouble(record["Float Min Value"].ToString()) : 0;
                Double floatMaxValue     = record["Float Max Value"] != null && !string.IsNullOrEmpty(Convert.ToString(record["Float Max Value"])) && Convert.ToDouble(record["Float Max Value"].ToString()) >= 0 && Convert.ToDouble(record["Float Max Value"].ToString()) <= 1000000000 ? Convert.ToDouble(record["Float Max Value"].ToString()) : 1000000000;

                int     decimalPrecision = record["Decimal Precision"] != null && !string.IsNullOrEmpty(Convert.ToString(record["Decimal Precision"])) ? Convert.ToInt32(record["Decimal Precision"].ToString()) : 2;
                Decimal decimalMinValue  = record["Decimal Min Value"] != null && !string.IsNullOrEmpty(Convert.ToString(record["Decimal Min Value"])) && Convert.ToDecimal(record["Decimal Min Value"].ToString()) >= -100000000000 && Convert.ToDecimal(record["Decimal Min Value"].ToString()) <= 100000000000 ? Convert.ToDecimal(record["Decimal Min Value"].ToString()) : -100000000000;
                Decimal decimalMaxValue  = record["Decimsl Max Value"] != null && !string.IsNullOrEmpty(Convert.ToString(record["Decimsl Max Value"])) && Convert.ToDecimal(record["Decimsl Max Value"].ToString()) >= -100000000000 && Convert.ToDecimal(record["Decimsl Max Value"].ToString()) <= 100000000000 ? Convert.ToDecimal(record["Decimsl Max Value"].ToString()) : 100000000000;

                Double currencyMinValue = record["Currency Min Value"] != null && !string.IsNullOrEmpty(Convert.ToString(record["Currency Min Value"])) && Convert.ToDouble(record["Currency Min Value"].ToString()) >= -922337203685477 && Convert.ToDouble(record["Currency Min Value"].ToString()) <= 922337203685477 ? Convert.ToDouble(record["Currency Min Value"].ToString()) : -922337203685477;
                Double currencyMaxValue = record["Currency Max Value"] != null && !string.IsNullOrEmpty(Convert.ToString(record["Currency Max Value"])) && Convert.ToDouble(record["Currency Max Value"].ToString()) >= -922337203685477 && Convert.ToDouble(record["Currency Max Value"].ToString()) <= 922337203685477 ? Convert.ToDouble(record["Currency Max Value"].ToString()) : 922337203685477;

                Microsoft.Xrm.Sdk.Metadata.ImeMode imeMode = GetIMEMode(record["IME Mode"].ToString().ToLower());

                if (record["Currency precision"] != null && !string.IsNullOrEmpty(Convert.ToString(record["Currency precision"]).ToLower()))
                {
                    switch (Convert.ToString(record["Currency precision"]).ToLower().Trim())
                    {
                    case "pricing decimal precision":
                        precisionSource = 1;
                        break;

                    case "currency precision":
                        precisionSource = 2;
                        break;

                    default:
                        currencyPrecision = Convert.ToInt32(Convert.ToString(record["Currency precision"]));
                        break;
                    }
                }

                bool isAuditEnabled       = record["AuditEnable"] != null && record["AuditEnable"].ToString().ToLower() == "yes" ? true : false;
                bool isValidForAdvancFind = record["IsValidForAdvancedFind"] != null && record["IsValidForAdvancedFind"].ToString().ToLower() == "yes" ? true : false;
                #endregion # Read From Datatable #

                switch (reqLevelText.ToLower().Trim())
                {
                case "boolean":
                    // Create a boolean attribute
                    createMetadata = new BooleanAttributeMetadata
                    {
                        SchemaName    = attributeSchemaName,
                        DisplayName   = new Microsoft.Xrm.Sdk.Label(attributeDisplayName, _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(requirementLevel),
                        Description   = new Microsoft.Xrm.Sdk.Label(attributeDiscription, _languageCode),
                        // Set extended properties
                        OptionSet = new BooleanOptionSetMetadata(
                            new OptionMetadata(new Microsoft.Xrm.Sdk.Label("Yes", _languageCode), 1),
                            new OptionMetadata(new Microsoft.Xrm.Sdk.Label("No", _languageCode), 0)
                            ),
                        DefaultValue           = boolDefaultValue,
                        IsAuditEnabled         = new BooleanManagedProperty(isAuditEnabled),
                        IsValidForAdvancedFind = new BooleanManagedProperty(isValidForAdvancFind),
                    };
                    break;

                case "date and time":
                    createMetadata = new DateTimeAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = attributeSchemaName,
                        DisplayName   = new Microsoft.Xrm.Sdk.Label(attributeDisplayName, _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(requirementLevel),
                        Description   = new Microsoft.Xrm.Sdk.Label(attributeDiscription, _languageCode),
                        // Set extended properties
                        Format                 = dateFormat,
                        ImeMode                = imeMode,
                        IsAuditEnabled         = new BooleanManagedProperty(isAuditEnabled),
                        IsValidForAdvancedFind = new BooleanManagedProperty(isValidForAdvancFind),
                    };
                    break;

                case "multiple line of text":
                    createMetadata = new MemoAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = attributeSchemaName,
                        DisplayName   = new Microsoft.Xrm.Sdk.Label(attributeDisplayName, _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(requirementLevel),
                        Description   = new Microsoft.Xrm.Sdk.Label(attributeDiscription, _languageCode),
                        // Set extended properties
                        ImeMode                = imeMode,
                        IsAuditEnabled         = new BooleanManagedProperty(isAuditEnabled),
                        IsValidForAdvancedFind = new BooleanManagedProperty(isValidForAdvancFind),
                        MaxLength              = stringLength
                    };
                    break;

                case "whole number":
                    createMetadata = new IntegerAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = attributeSchemaName,
                        DisplayName   = new Microsoft.Xrm.Sdk.Label(attributeDisplayName, _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(requirementLevel),
                        Description   = new Microsoft.Xrm.Sdk.Label(attributeDiscription, _languageCode),
                        // Set extended properties
                        // ImeMode = imeMode,// in crm 2016 ths feature is there
                        // Set extended properties
                        Format                 = IntegerFormat.None,
                        MaxValue               = Convert.ToInt32(intMaxValue),
                        MinValue               = Convert.ToInt32(intMinValue),
                        IsAuditEnabled         = new BooleanManagedProperty(isAuditEnabled),
                        IsValidForAdvancedFind = new BooleanManagedProperty(isValidForAdvancFind)
                    };
                    break;

                case "floating point number":
                    createMetadata = new DoubleAttributeMetadata
                    {
                        SchemaName             = attributeSchemaName,
                        DisplayName            = new Microsoft.Xrm.Sdk.Label(attributeDisplayName, _languageCode),
                        RequiredLevel          = new AttributeRequiredLevelManagedProperty(requirementLevel),
                        Description            = new Microsoft.Xrm.Sdk.Label(attributeDiscription, _languageCode),
                        MaxValue               = floatMaxValue,
                        MinValue               = floatMinValue,
                        Precision              = floatingPrecision,
                        IsAuditEnabled         = new BooleanManagedProperty(isAuditEnabled),
                        IsValidForAdvancedFind = new BooleanManagedProperty(isValidForAdvancFind),
                        ImeMode = imeMode
                    };
                    break;

                case "decimal number":
                    createMetadata = new DecimalAttributeMetadata
                    {
                        SchemaName             = attributeSchemaName,
                        DisplayName            = new Microsoft.Xrm.Sdk.Label(attributeDisplayName, _languageCode),
                        RequiredLevel          = new AttributeRequiredLevelManagedProperty(requirementLevel),
                        Description            = new Microsoft.Xrm.Sdk.Label(attributeDiscription, _languageCode),
                        MaxValue               = decimalMaxValue,
                        MinValue               = decimalMinValue,
                        Precision              = decimalPrecision,
                        IsAuditEnabled         = new BooleanManagedProperty(isAuditEnabled),
                        IsValidForAdvancedFind = new BooleanManagedProperty(isValidForAdvancFind),
                        ImeMode = imeMode
                    };
                    break;

                case "currency":
                    createMetadata = new MoneyAttributeMetadata
                    {
                        SchemaName      = attributeSchemaName,
                        DisplayName     = new Microsoft.Xrm.Sdk.Label(attributeDisplayName, _languageCode),
                        RequiredLevel   = new AttributeRequiredLevelManagedProperty(requirementLevel),
                        Description     = new Microsoft.Xrm.Sdk.Label(attributeDiscription, _languageCode),
                        MaxValue        = currencyMaxValue,
                        MinValue        = currencyMinValue,
                        Precision       = currencyPrecision,
                        PrecisionSource = precisionSource,
                        ImeMode         = imeMode
                    };
                    break;

                case "option set":

                    OptionMetadataCollection optionMetadataCollection = GetOptionMetadata(optionSetValues);
                    OptionSetMetadata        Optionmedata             = new OptionSetMetadata();
                    if (optionMetadataCollection != null && optionMetadataCollection.Count() > 0)
                    {
                        Optionmedata.Options.AddRange(optionMetadataCollection);
                    }
                    Optionmedata.IsGlobal      = isGlobal;
                    Optionmedata.OptionSetType = OptionSetType.Picklist;

                    createMetadata = new PicklistAttributeMetadata
                    {
                        SchemaName    = attributeSchemaName,
                        DisplayName   = new Microsoft.Xrm.Sdk.Label(attributeDisplayName, _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(requirementLevel),
                        Description   = new Microsoft.Xrm.Sdk.Label(attributeDiscription, _languageCode),
                        OptionSet     = Optionmedata
                    };
                    break;

                case "single line of text":
                    createMetadata = new StringAttributeMetadata
                    {
                        SchemaName    = attributeSchemaName,
                        DisplayName   = new Microsoft.Xrm.Sdk.Label(attributeDisplayName, _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(requirementLevel),
                        Description   = new Microsoft.Xrm.Sdk.Label(attributeDiscription, _languageCode),
                        // Set extended properties
                        ImeMode                = imeMode,
                        IsAuditEnabled         = new BooleanManagedProperty(isAuditEnabled),
                        IsValidForAdvancedFind = new BooleanManagedProperty(isValidForAdvancFind),
                        MaxLength              = stringLength
                    };
                    break;
                }
                CreateAttributeRequest request = new CreateAttributeRequest
                {
                    Attribute  = createMetadata,
                    EntityName = ApplicationSetting.SelectedEntity.LogicalName
                };
                try
                {
                    Service.Execute(request);
                    result = "Success";
                }
                catch (FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault> ex)
                {
                    result = ex.Message;
                }
                catch (Exception ex)
                {
                    result = ex.Message;
                }
            }
            catch (Exception ex)
            {
                result = ex.Message;
            }
        }
 public DecimalAttributeMetadataInfo(DecimalAttributeMetadata amd)
     : base(amd)
 {
     this.amd = amd;
 }
        private IEnumerable <string> checkDifferenceAttributeMetadata(AttributeMetadata originalAttributeMetadata, AttributeMetadata readAttributeMetadata)
        {
            List <string> attributesToUpdate = checkGlobalDifferenceAttributeMetadata(originalAttributeMetadata, readAttributeMetadata);

            switch (originalAttributeMetadata.AttributeType)
            {
            case AttributeTypeCode.Integer:
                IntegerAttributeMetadata intattrMetadata = originalAttributeMetadata as IntegerAttributeMetadata;
                attributesToUpdate.AddRange(checkDifferenceIntegerAttribute(intattrMetadata, readAttributeMetadata as IntegerAttributeMetadata));
                originalAttributeMetadata = intattrMetadata;
                break;

            case AttributeTypeCode.DateTime:
                DateTimeAttributeMetadata dateattrMetadata = originalAttributeMetadata as DateTimeAttributeMetadata;
                attributesToUpdate.AddRange(checkDifferenceDateTimeAttribute(dateattrMetadata, readAttributeMetadata as DateTimeAttributeMetadata));
                originalAttributeMetadata = dateattrMetadata;
                break;

            case AttributeTypeCode.String:
                StringAttributeMetadata strattrMetadata = originalAttributeMetadata as StringAttributeMetadata;
                attributesToUpdate.AddRange(checkDifferenceStringAttribute(strattrMetadata, readAttributeMetadata as StringAttributeMetadata));
                originalAttributeMetadata = strattrMetadata;
                break;

            case AttributeTypeCode.Picklist:
                PicklistAttributeMetadata pklattrMetadata = originalAttributeMetadata as PicklistAttributeMetadata;
                attributesToUpdate.AddRange(checkDifferencePicklistAttribute(pklattrMetadata, readAttributeMetadata as PicklistAttributeMetadata));
                originalAttributeMetadata = pklattrMetadata;
                break;

            case AttributeTypeCode.Memo:
                MemoAttributeMetadata memattrMetadata = originalAttributeMetadata as MemoAttributeMetadata;
                attributesToUpdate.AddRange(checkDifferenceMemoAttribute(memattrMetadata, readAttributeMetadata as MemoAttributeMetadata));
                originalAttributeMetadata = memattrMetadata;
                break;

            case AttributeTypeCode.Double:
                DoubleAttributeMetadata dblattrMetadata = originalAttributeMetadata as DoubleAttributeMetadata;
                attributesToUpdate.AddRange(checkDifferenceDoubleAttribute(dblattrMetadata, readAttributeMetadata as DoubleAttributeMetadata));
                originalAttributeMetadata = dblattrMetadata;
                break;

            case AttributeTypeCode.Decimal:
                DecimalAttributeMetadata dcmattrMetadata = originalAttributeMetadata as DecimalAttributeMetadata;
                attributesToUpdate.AddRange(checkDifferenceDecimalAttribute(dcmattrMetadata, readAttributeMetadata as DecimalAttributeMetadata));
                originalAttributeMetadata = dcmattrMetadata;
                break;

            case AttributeTypeCode.Boolean:
                BooleanAttributeMetadata blnattrMetadata = originalAttributeMetadata as BooleanAttributeMetadata;
                attributesToUpdate.AddRange(checkDifferenceBooleanAttribute(blnattrMetadata, readAttributeMetadata as BooleanAttributeMetadata));
                originalAttributeMetadata = blnattrMetadata;
                break;

            case AttributeTypeCode.Money:
                MoneyAttributeMetadata mnyattrMetadata = originalAttributeMetadata as MoneyAttributeMetadata;
                attributesToUpdate.AddRange(checkDifferenceMoneyAttribute(mnyattrMetadata, readAttributeMetadata as MoneyAttributeMetadata));
                originalAttributeMetadata = mnyattrMetadata;
                break;
            }
            return(attributesToUpdate);
        }
 private AttributeMetadata CloneAttributes(DecimalAttributeMetadata att)
 {
     return new DecimalAttributeMetadata
     {
         MaxValue = att.MaxValue,
         MinValue = att.MinValue,
         Precision = att.Precision,
         ImeMode = att.ImeMode,
         FormulaDefinition = att.FormulaDefinition
     };
 }
 private DecimalAttributeMetadata CreateDecimalAttributeMetadata(AttributeTemplate attributeTemplate)
 {
     var decimalAttributeMetadata = new DecimalAttributeMetadata
     {
         MinValue = -100000000000.00M,
         MaxValue = 100000000000.00M,
         Precision = 2
     };
     return decimalAttributeMetadata;
 }
Example #30
0
        public void CreateAttribute(CrmServiceClient service, string entityname, List <DxEntityAttribute> entityAttributes)
        {
            #region Attribute Metadata
            StringAttributeMetadata   dxStringAttributeMetadata   = null;
            DecimalAttributeMetadata  dxDecimalAttributeMetadata  = null;
            IntegerAttributeMetadata  dxIntegerAttributeMetadata  = null;
            MoneyAttributeMetadata    dxMoneyAttributeMetadata    = null;
            DateTimeAttributeMetadata dxDateTimeAttributeMetadata = null;
            #endregion
            AttributeMetadata attributeMetadata = null;

            foreach (DxEntityAttribute dxEntityAttribute in entityAttributes)
            {
                switch (dxEntityAttribute.PType)
                {
                case 1:
                    dxStringAttributeMetadata = new StringAttributeMetadata
                    {
                        SchemaName = String.Format("{0}_{1}", entityname.Substring(0, entityname.IndexOf("_")),
                                                   dxEntityAttribute.PSchemaName.ToLower().Trim()),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        MaxLength     = dxEntityAttribute.StringAttribute.PMaxLength,
                        FormatName    = dxEntityAttribute.StringAttribute.PStringFormatName,
                        DisplayName   =
                            new Microsoft.Xrm.Sdk.Label(dxEntityAttribute.PDisplayName, 3082),
                        Description =
                            new Microsoft.Xrm.Sdk.Label(dxEntityAttribute.PDescription, 3082),
                    };
                    attributeMetadata = dxStringAttributeMetadata;
                    break;

                case 2:
                    dxDecimalAttributeMetadata = new DecimalAttributeMetadata
                    {
                        SchemaName = String.Format("{0}_{1}", entityname.Substring(0, entityname.IndexOf("_")),
                                                   dxEntityAttribute.PSchemaName.ToLower().Trim()),
                        DisplayName   = new Microsoft.Xrm.Sdk.Label(dxEntityAttribute.PDisplayName, 3082),
                        Description   = new Microsoft.Xrm.Sdk.Label(dxEntityAttribute.PDescription, 3082),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),

                        MaxValue  = dxEntityAttribute.DecimalAttribute.PMaxValue,
                        MinValue  = dxEntityAttribute.DecimalAttribute.PMinValue,
                        Precision = dxEntityAttribute.DecimalAttribute.PPrecision
                    };
                    attributeMetadata = dxDecimalAttributeMetadata;
                    break;

                case 3:
                    dxIntegerAttributeMetadata = new IntegerAttributeMetadata
                    {
                        SchemaName = String.Format("{0}_{1}", entityname.Substring(0, entityname.IndexOf("_")),
                                                   dxEntityAttribute.PSchemaName.ToLower().Trim()),
                        DisplayName   = new Microsoft.Xrm.Sdk.Label(dxEntityAttribute.PDisplayName, 3082),
                        Description   = new Microsoft.Xrm.Sdk.Label(dxEntityAttribute.PDescription, 3082),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),

                        MaxValue = dxEntityAttribute.IntegerAttribute.PMaxValue,
                        MinValue = dxEntityAttribute.IntegerAttribute.PMinValue,
                        Format   = dxEntityAttribute.IntegerAttribute.PFormat
                    };
                    attributeMetadata = dxIntegerAttributeMetadata;
                    break;

                case 4:
                    dxMoneyAttributeMetadata = new MoneyAttributeMetadata
                    {
                        SchemaName = String.Format("{0}_{1}", entityname.Substring(0, entityname.IndexOf("_")),
                                                   dxEntityAttribute.PSchemaName.ToLower().Trim()),
                        DisplayName   = new Microsoft.Xrm.Sdk.Label(dxEntityAttribute.PDisplayName, 3082),
                        Description   = new Microsoft.Xrm.Sdk.Label(dxEntityAttribute.PDescription, 3082),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),

                        MaxValue        = dxEntityAttribute.MoneyAttribute.PMaxValue,
                        MinValue        = dxEntityAttribute.MoneyAttribute.PMinValue,
                        Precision       = dxEntityAttribute.MoneyAttribute.PPrecision,
                        PrecisionSource = dxEntityAttribute.MoneyAttribute.PPrecisionSource,
                        ImeMode         = dxEntityAttribute.MoneyAttribute.PImeMode
                    };

                    attributeMetadata = dxMoneyAttributeMetadata;
                    break;

                case 5:
                    dxDateTimeAttributeMetadata = new DateTimeAttributeMetadata
                    {
                        SchemaName = String.Format("{0}_{1}", entityname.Substring(0, entityname.IndexOf("_")),
                                                   dxEntityAttribute.PSchemaName.ToLower().Trim()),
                        DisplayName   = new Microsoft.Xrm.Sdk.Label(dxEntityAttribute.PDisplayName, 3082),
                        Description   = new Microsoft.Xrm.Sdk.Label(dxEntityAttribute.PDescription, 3082),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),

                        Format  = dxEntityAttribute.DateTimeAttribute.PFormat,
                        ImeMode = dxEntityAttribute.DateTimeAttribute.PImeMode
                    };
                    attributeMetadata = dxDateTimeAttributeMetadata;
                    break;
                }

                CreateAttributeRequest createBankNameAttributeRequest = new CreateAttributeRequest
                {
                    EntityName = entityname,
                    Attribute  = attributeMetadata,
                };

                service.OrganizationServiceProxy.Execute(createBankNameAttributeRequest);
            }
        }
Example #31
0
        /// <summary>
        /// Gets the default sql scale for the crm decimal attribute.
        /// </summary>
        /// <param name="metadata"></param>
        /// <returns></returns>
        public static int DefaultSqlScale(this DecimalAttributeMetadata metadata)
        {
            int scale = DecimalAttributeMetadata.MinSupportedPrecision;

            return(scale);
        }
Example #32
0
        /// <summary>
        /// Gets the default sql precision for the crm decimal attribute.
        /// </summary>
        /// <param name="metadata"></param>
        /// <returns></returns>
        public static int DefaultSqlPrecision(this DecimalAttributeMetadata metadata)
        {
            var precision = Math.Max(Math.Truncate(Math.Abs(DecimalAttributeMetadata.MaxSupportedValue)).ToString().Length, Math.Truncate(Math.Abs(DecimalAttributeMetadata.MinSupportedValue)).ToString().Length);

            return(precision + DefaultSqlScale(metadata));
        }
Example #33
0
        /// <summary>
        /// Create and configure the organization service proxy.
        /// Create few types of attributes.
        /// Insert status in the existing status list.
        /// Retrieve attribute.
        /// Update attribute.
        /// Update existing state value.
        /// Optionally delete/revert any attributes
        /// that were created/changed for this sample.
        /// </summary>
        /// <param name="serverConfig">Contains server connection information.</param>
        /// <param name="promptForDelete">When True, the user will be prompted to delete all
        /// created entities.</param>
        public void Run(ServerConnection.Configuration serverConfig, bool promptForDelete)
        {
            try
            {
                // Connect to the Organization service.
                // The using statement assures that the service proxy will be properly disposed.
                using (_serviceProxy = ServerConnection.GetOrganizationProxy(serverConfig))
                {
                    // This statement is required to enable early-bound type support.
                    _serviceProxy.EnableProxyTypes();

                    //<snippetWorkWithAttributes1>
                    #region How to create attributes
                    //<snippetWorkWithAttributes2>
                    // Create storage for new attributes being created
                    addedAttributes = new List <AttributeMetadata>();

                    // Create a boolean attribute
                    BooleanAttributeMetadata boolAttribute = new BooleanAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_boolean",
                        DisplayName   = new Label("Sample Boolean", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("Boolean Attribute", _languageCode),
                        // Set extended properties
                        OptionSet = new BooleanOptionSetMetadata(
                            new OptionMetadata(new Label("True", _languageCode), 1),
                            new OptionMetadata(new Label("False", _languageCode), 0)
                            )
                    };

                    // Add to list
                    addedAttributes.Add(boolAttribute);

                    // Create a date time attribute
                    DateTimeAttributeMetadata dtAttribute = new DateTimeAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_datetime",
                        DisplayName   = new Label("Sample DateTime", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("DateTime Attribute", _languageCode),
                        // Set extended properties
                        Format  = DateTimeFormat.DateOnly,
                        ImeMode = ImeMode.Disabled
                    };

                    // Add to list
                    addedAttributes.Add(dtAttribute);

                    // Create a decimal attribute
                    DecimalAttributeMetadata decimalAttribute = new DecimalAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_decimal",
                        DisplayName   = new Label("Sample Decimal", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("Decimal Attribute", _languageCode),
                        // Set extended properties
                        MaxValue  = 100,
                        MinValue  = 0,
                        Precision = 1
                    };

                    // Add to list
                    addedAttributes.Add(decimalAttribute);

                    // Create a integer attribute
                    IntegerAttributeMetadata integerAttribute = new IntegerAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_integer",
                        DisplayName   = new Label("Sample Integer", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("Integer Attribute", _languageCode),
                        // Set extended properties
                        Format   = IntegerFormat.None,
                        MaxValue = 100,
                        MinValue = 0
                    };

                    // Add to list
                    addedAttributes.Add(integerAttribute);

                    // Create a memo attribute
                    MemoAttributeMetadata memoAttribute = new MemoAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_memo",
                        DisplayName   = new Label("Sample Memo", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("Memo Attribute", _languageCode),
                        // Set extended properties
                        Format    = StringFormat.TextArea,
                        ImeMode   = ImeMode.Disabled,
                        MaxLength = 500
                    };

                    // Add to list
                    addedAttributes.Add(memoAttribute);

                    // Create a money attribute
                    MoneyAttributeMetadata moneyAttribute = new MoneyAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_money",
                        DisplayName   = new Label("Money Picklist", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("Money Attribue", _languageCode),
                        // Set extended properties
                        MaxValue        = 1000.00,
                        MinValue        = 0.00,
                        Precision       = 1,
                        PrecisionSource = 1,
                        ImeMode         = ImeMode.Disabled
                    };

                    // Add to list
                    addedAttributes.Add(moneyAttribute);

                    // Create a picklist attribute
                    PicklistAttributeMetadata pickListAttribute =
                        new PicklistAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_picklist",
                        DisplayName   = new Label("Sample Picklist", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("Picklist Attribute", _languageCode),
                        // Set extended properties
                        // Build local picklist options
                        OptionSet = new OptionSetMetadata
                        {
                            IsGlobal      = false,
                            OptionSetType = OptionSetType.Picklist,
                            Options       =
                            {
                                new OptionMetadata(
                                    new Label("Created",                        _languageCode), null),
                                new OptionMetadata(
                                    new Label("Updated",                        _languageCode), null),
                                new OptionMetadata(
                                    new Label("Deleted",                        _languageCode), null)
                            }
                        }
                    };

                    // Add to list
                    addedAttributes.Add(pickListAttribute);

                    // Create a string attribute
                    StringAttributeMetadata stringAttribute = new StringAttributeMetadata
                    {
                        // Set base properties
                        SchemaName    = "new_string",
                        DisplayName   = new Label("Sample String", _languageCode),
                        RequiredLevel = new AttributeRequiredLevelManagedProperty(AttributeRequiredLevel.None),
                        Description   = new Label("String Attribute", _languageCode),
                        // Set extended properties
                        MaxLength = 100
                    };

                    // Add to list
                    addedAttributes.Add(stringAttribute);

                    // NOTE: LookupAttributeMetadata cannot be created outside the context of a relationship.
                    // Refer to the WorkWithRelationships.cs reference SDK sample for an example of this attribute type.

                    // NOTE: StateAttributeMetadata and StatusAttributeMetadata cannot be created via the SDK.

                    foreach (AttributeMetadata anAttribute in addedAttributes)
                    {
                        // Create the request.
                        CreateAttributeRequest createAttributeRequest = new CreateAttributeRequest
                        {
                            EntityName = Contact.EntityLogicalName,
                            Attribute  = anAttribute
                        };

                        // Execute the request.
                        _serviceProxy.Execute(createAttributeRequest);

                        Console.WriteLine("Created the attribute {0}.", anAttribute.SchemaName);
                    }
                    //</snippetWorkWithAttributes2>
                    #endregion How to create attributes

                    #region How to insert status
                    //<snippetWorkWithAttributes3>
                    // Use InsertStatusValueRequest message to insert a new status
                    // in an existing status attribute.
                    // Create the request.
                    InsertStatusValueRequest insertStatusValueRequest =
                        new InsertStatusValueRequest
                    {
                        AttributeLogicalName = "statuscode",
                        EntityLogicalName    = Contact.EntityLogicalName,
                        Label     = new Label("Dormant", _languageCode),
                        StateCode = 0
                    };

                    // Execute the request and store newly inserted value
                    // for cleanup, used later part of this sample.
                    _insertedStatusValue = ((InsertStatusValueResponse)_serviceProxy.Execute(
                                                insertStatusValueRequest)).NewOptionValue;

                    Console.WriteLine("Created {0} with the value of {1}.",
                                      insertStatusValueRequest.Label.LocalizedLabels[0].Label,
                                      _insertedStatusValue);
                    //</snippetWorkWithAttributes3>
                    #endregion How to insert status

                    #region How to retrieve attribute
                    //<snippetWorkWithAttributes4>
                    // Create the request
                    RetrieveAttributeRequest attributeRequest = new RetrieveAttributeRequest
                    {
                        EntityLogicalName = Contact.EntityLogicalName,
                        LogicalName       = "new_string",
                        // When RetrieveAsIfPublished property is set to false, retrieves only the currently published changes. Default setting of the property is false.
                        // When RetrieveAsIfPublished property is set to true, retrieves the changes that are published and those changes that have not been published.
                        RetrieveAsIfPublished = false
                    };

                    // Execute the request
                    RetrieveAttributeResponse attributeResponse =
                        (RetrieveAttributeResponse)_serviceProxy.Execute(attributeRequest);

                    Console.WriteLine("Retrieved the attribute {0}.",
                                      attributeResponse.AttributeMetadata.SchemaName);
                    //</snippetWorkWithAttributes4>
                    #endregion How to retrieve attribute

                    #region How to update attribute
                    //<snippetWorkWithAttributes5>
                    // Modify the retrieved attribute
                    AttributeMetadata retrievedAttributeMetadata =
                        attributeResponse.AttributeMetadata;
                    retrievedAttributeMetadata.DisplayName =
                        new Label("Update String Attribute", _languageCode);

                    // Update an attribute retrieved via RetrieveAttributeRequest
                    UpdateAttributeRequest updateRequest = new UpdateAttributeRequest
                    {
                        Attribute   = retrievedAttributeMetadata,
                        EntityName  = Contact.EntityLogicalName,
                        MergeLabels = false
                    };

                    // Execute the request
                    _serviceProxy.Execute(updateRequest);

                    Console.WriteLine("Updated the attribute {0}.",
                                      retrievedAttributeMetadata.SchemaName);
                    //</snippetWorkWithAttributes5>
                    #endregion How to update attribute

                    #region How to update state value
                    //<snippetWorkWithAttributes6>
                    // Modify the state value label from Active to Open.
                    // Create the request.
                    UpdateStateValueRequest updateStateValue = new UpdateStateValueRequest
                    {
                        AttributeLogicalName = "statecode",
                        EntityLogicalName    = Contact.EntityLogicalName,
                        Value = 1,
                        Label = new Label("Open", _languageCode)
                    };

                    // Execute the request.
                    _serviceProxy.Execute(updateStateValue);

                    Console.WriteLine(
                        "Updated {0} state attribute of {1} entity from 'Active' to '{2}'.",
                        updateStateValue.AttributeLogicalName,
                        updateStateValue.EntityLogicalName,
                        updateStateValue.Label.LocalizedLabels[0].Label
                        );
                    //</snippetWorkWithAttributes6>
                    #endregion How to update state value

                    #region How to insert a new option item in a local option set
                    //<snippetWorkWithAttributes7>
                    // Create a request.
                    InsertOptionValueRequest insertOptionValueRequest =
                        new InsertOptionValueRequest
                    {
                        AttributeLogicalName = "new_picklist",
                        EntityLogicalName    = Contact.EntityLogicalName,
                        Label = new Label("New Picklist Label", _languageCode)
                    };

                    // Execute the request.
                    int insertOptionValue = ((InsertOptionValueResponse)_serviceProxy.Execute(
                                                 insertOptionValueRequest)).NewOptionValue;

                    Console.WriteLine("Created {0} with the value of {1}.",
                                      insertOptionValueRequest.Label.LocalizedLabels[0].Label,
                                      insertOptionValue);
                    //</snippetWorkWithAttributes7>
                    #endregion How to insert a new option item in a local option set

                    #region How to change the order of options of a local option set
                    //<snippetWorkWithAttributes8>
                    // Use the RetrieveAttributeRequest message to retrieve
                    // a attribute by it's logical name.
                    RetrieveAttributeRequest retrieveAttributeRequest =
                        new RetrieveAttributeRequest
                    {
                        EntityLogicalName = Contact.EntityLogicalName,
                        LogicalName       = "new_picklist",
                        // When RetrieveAsIfPublished property is set to false, retrieves only the currently published changes. Default setting of the property is false.
                        // When RetrieveAsIfPublished property is set to true, retrieves the changes that are published and those changes that have not been published.
                        RetrieveAsIfPublished = false
                    };

                    // Execute the request.
                    RetrieveAttributeResponse retrieveAttributeResponse =
                        (RetrieveAttributeResponse)_serviceProxy.Execute(
                            retrieveAttributeRequest);

                    // Access the retrieved attribute.
                    PicklistAttributeMetadata retrievedPicklistAttributeMetadata =
                        (PicklistAttributeMetadata)
                        retrieveAttributeResponse.AttributeMetadata;

                    // Get the current options list for the retrieved attribute.
                    OptionMetadata[] optionList =
                        retrievedPicklistAttributeMetadata.OptionSet.Options.ToArray();

                    // Change the order of the original option's list.
                    // Use the OrderBy (OrderByDescending) linq function to sort options in
                    // ascending (descending) order according to label text.
                    // For ascending order use this:
                    var updateOptionList =
                        optionList.OrderBy(x => x.Label.LocalizedLabels[0].Label).ToList();

                    // For descending order use this:
                    // var updateOptionList =
                    //      optionList.OrderByDescending(
                    //      x => x.Label.LocalizedLabels[0].Label).ToList();

                    // Create the request.
                    OrderOptionRequest orderOptionRequest = new OrderOptionRequest
                    {
                        // Set the properties for the request.
                        AttributeLogicalName = "new_picklist",
                        EntityLogicalName    = Contact.EntityLogicalName,
                        // Set the changed order using Select linq function
                        // to get only values in an array from the changed option list.
                        Values = updateOptionList.Select(x => x.Value.Value).ToArray()
                    };

                    // Execute the request
                    _serviceProxy.Execute(orderOptionRequest);

                    Console.WriteLine("Option Set option order changed");
                    //</snippetWorkWithAttributes8>
                    #endregion How to change the order of options of a global option set

                    // NOTE: All customizations must be published before they can be used.
                    _serviceProxy.Execute(new PublishAllXmlRequest());
                    Console.WriteLine("Published all customizations.");
                    //</snippetWorkWithAttributes1>

                    DeleteRequiredRecords(promptForDelete);
                }
            }

            // Catch any service fault exceptions that Microsoft Dynamics CRM throws.
            catch (FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault> )
            {
                // You can handle an exception here or pass it back to the calling method.
                throw;
            }
        }
Example #34
0
        private RetrieveAttributeResponse ExecuteInternal(RetrieveAttributeRequest request)
        {
            var response   = new RetrieveAttributeResponse();
            var entityType =
                CrmServiceUtility.GetEarlyBoundProxyAssembly().GetTypes().FirstOrDefault(t =>
                                                                                         t.GetCustomAttribute <EntityLogicalNameAttribute>(true)?.LogicalName == request.EntityLogicalName);

            var propertyTypes = entityType?.GetProperties()
                                .Where(p =>
                                       p.GetCustomAttribute <AttributeLogicalNameAttribute>()?.LogicalName == request.LogicalName
                                       ).Select(p => p.PropertyType.IsGenericType
                    ? p.PropertyType.GenericTypeArguments.First()
                    : p.PropertyType).ToList();

            var propertyType = propertyTypes?.Count == 1
                ? propertyTypes[0]
                : propertyTypes?.FirstOrDefault(p => p != typeof(OptionSetValue) &&
                                                p != typeof(EntityReference));      // Handle OptionSets/EntityReferences that may have multiple properties

            if (propertyType == null)
            {
                throw new Exception($"Unable to find a property for Entity {request.EntityLogicalName} and property {request.LogicalName} in {CrmServiceUtility.GetEarlyBoundProxyAssembly().FullName}");
            }

            AttributeMetadata metadata;

            if (propertyType.IsEnum || propertyTypes.Any(p => p == typeof(OptionSetValue)))
            {
                metadata = CreateOptionSetAttributeMetadata(request, propertyType);
            }
            else if (propertyType == typeof(string))
            {
                metadata = new StringAttributeMetadata(request.LogicalName);
            }
            else if (propertyTypes.Any(p => p == typeof(EntityReference)))
            {
                metadata = new LookupAttributeMetadata
                {
                    LogicalName = request.LogicalName
                };
            }
#if !XRM_2013
            else if (propertyType == typeof(Guid))
            {
                metadata = new UniqueIdentifierAttributeMetadata
                {
                    LogicalName = request.LogicalName
                };
            }
#endif
            else if (propertyType == typeof(bool))
            {
                metadata = new BooleanAttributeMetadata
                {
                    LogicalName = request.LogicalName
                };
            }
            else if (propertyType == typeof(Money))
            {
                metadata = new MoneyAttributeMetadata
                {
                    LogicalName = request.LogicalName
                };
            }
            else if (propertyType == typeof(int))
            {
                metadata = new IntegerAttributeMetadata
                {
                    LogicalName = request.LogicalName
                };
            }
            else if (propertyType == typeof(long))
            {
                metadata = new BigIntAttributeMetadata
                {
                    LogicalName = request.LogicalName
                };
            }
            else if (propertyType == typeof(DateTime))
            {
                metadata = new DateTimeAttributeMetadata
                {
                    LogicalName = request.LogicalName
                };
            }
            else if (propertyType == typeof(double))
            {
                metadata = new DoubleAttributeMetadata
                {
                    LogicalName = request.LogicalName
                };
            }
            else if (propertyType == typeof(decimal))
            {
                metadata = new DecimalAttributeMetadata
                {
                    LogicalName = request.LogicalName
                };
            }
            else
            {
                throw new NotImplementedException($"Attribute Type of {propertyType.FullName} is not implemented.");
            }
            response.Results["AttributeMetadata"] = metadata;
            return(response);
        }
Example #35
0
        /// <summary>
        /// Add output columns
        /// </summary>
        /// <param name="propertyValue"></param>
        public void AddOutputColumns(String propertyValue)
        {
            if (!String.IsNullOrEmpty(propertyValue))
            {
                if (service == null)
                {
                    AcquireConnections(null);
                }

                if (service != null)
                {
                    DataTable dt = GetData(propertyValue, true);

                    IDTSOutput100 output = ComponentMetaData.OutputCollection[0];

                    output.OutputColumnCollection.RemoveAll();
                    output.ExternalMetadataColumnCollection.RemoveAll();

                    if (dt != null)
                    {
                        //Check if there are any rows in the datatable
                        if (dt.Rows != null && dt.Rows.Count > 0)
                        {
                            DataTable schemaDT = dt.CreateDataReader().GetSchemaTable();
                            foreach (DataRow row in schemaDT.Rows)
                            {
                                IDTSOutputColumn100 outputCol = output.OutputColumnCollection.New();



                                AttributeMetadata mdta = entMetadata.Attributes.FirstOrDefault(m => m.LogicalName == row["ColumnName"].ToString());

                                bool     isLong = false;
                                DataType dType  = DataRecordTypeToBufferType((Type)row["DataType"]);
                                dType = ConvertBufferDataTypeToFitManaged(dType, ref isLong);
                                int length    = ((int)row["ColumnSize"]) == -1 ? 4000 : (int)row["ColumnSize"];
                                int precision = row["NumericPrecision"] is System.DBNull ? 0 : (short)row["NumericPrecision"];
                                int scale     = row["NumericScale"] is System.DBNull ? 0 : (short)row["NumericScale"];
                                int codePage  = schemaDT.Locale.TextInfo.ANSICodePage;

                                switch (dType)
                                {
                                //case DataType.DT_DATE:

                                //    precision = 0;
                                //    scale = 0;
                                //    break;
                                case DataType.DT_STR:
                                case DataType.DT_TEXT:
                                    MemoAttributeMetadata att = (MemoAttributeMetadata)mdta;
                                    if (att.MaxLength.HasValue)
                                    {
                                        length = (int)att.MaxLength;
                                    }
                                    else
                                    {
                                        length = 1048576;
                                    }

                                    precision = 0;
                                    scale     = 0;
                                    break;

                                case DataType.DT_CY:
                                    MoneyAttributeMetadata attMoney = (MoneyAttributeMetadata)mdta;
                                    if (attMoney.PrecisionSource == 0)     //TODO get the other types of precision sources
                                    {
                                        if (attMoney.Precision.HasValue)
                                        {
                                            scale = (int)attMoney.Precision;
                                        }
                                        else
                                        {
                                            scale = 2;
                                        }
                                    }
                                    else
                                    {
                                        scale = 4;
                                    }

                                    int precision1 = 0, precision2 = 0;

                                    if (attMoney.MaxValue.HasValue)
                                    {
                                        precision1 = attMoney.MaxValue.Value.ToString().Length;
                                    }

                                    if (attMoney.MinValue.HasValue)
                                    {
                                        precision2 = attMoney.MinValue.Value.ToString().Length;
                                    }
                                    if (precision1 > precision2)
                                    {
                                        precision = precision1;
                                    }
                                    else
                                    {
                                        precision = precision2;
                                    }

                                    length   = 0;
                                    codePage = 0;
                                    if (precision == 0)
                                    {
                                        precision = 23;
                                    }

                                    if (precision > 38)
                                    {
                                        precision = 38;
                                    }
                                    if (scale > precision)
                                    {
                                        scale = precision;
                                    }
                                    break;

                                case DataType.DT_NUMERIC:
                                case DataType.DT_DECIMAL:
                                    DecimalAttributeMetadata attDecimal = (DecimalAttributeMetadata)mdta;

                                    if (attDecimal.Precision.HasValue)
                                    {
                                        scale = (int)attDecimal.Precision;
                                    }
                                    else
                                    {
                                        scale = 2;
                                    }


                                    int precisiondec1 = 0, precisiondec2 = 0;

                                    if (attDecimal.MaxValue.HasValue)
                                    {
                                        precisiondec1 = attDecimal.MaxValue.Value.ToString().Length;
                                    }

                                    if (attDecimal.MinValue.HasValue)
                                    {
                                        precisiondec2 = attDecimal.MinValue.Value.ToString().Length;
                                    }
                                    if (precisiondec1 > precisiondec2)
                                    {
                                        precision = precisiondec1;
                                    }
                                    else
                                    {
                                        precision = precisiondec2;
                                    }

                                    length   = 0;
                                    codePage = 0;
                                    if (precision == 0)
                                    {
                                        precision = 23;
                                    }

                                    if (precision > 38)
                                    {
                                        precision = 38;
                                    }
                                    if (scale > precision)
                                    {
                                        scale = precision;
                                    }
                                    break;


                                case DataType.DT_WSTR:



                                    if (mdta.GetType() == typeof(StringAttributeMetadata))
                                    {
                                        StringAttributeMetadata attstring = (StringAttributeMetadata)mdta;
                                        if (attstring.MaxLength.HasValue)
                                        {
                                            length = (int)attstring.MaxLength;
                                        }
                                        else
                                        {
                                            length = 4000;
                                        }
                                    }
                                    else
                                    {
                                        MemoAttributeMetadata attmemo = (MemoAttributeMetadata)mdta;
                                        length = (int)attmemo.MaxLength;
                                    }



                                    precision = 0;
                                    scale     = 0;
                                    codePage  = 0;
                                    break;

                                default:
                                    length    = 0;
                                    precision = 0;
                                    scale     = 0;
                                    codePage  = 0;
                                    break;
                                }

                                outputCol.Name = row["ColumnName"].ToString();
                                outputCol.SetDataTypeProperties(dType, length, precision, scale, codePage);

                                CreateExternalMetaDataColumn(output, outputCol);
                            }
                        }
                    }
                }
            }
        }
 public DecimalAttributeMetadataInfo(DecimalAttributeMetadata amd)
     : base(amd)
 {
     this.amd = amd;
 }
Example #37
0
        public void CreateOrUpdateDecimalAttribute(string schemaName, string displayName, string description,
            bool isRequired, bool audit, bool searchable, string recordType,
            decimal minimum, decimal maximum)
        {
            DecimalAttributeMetadata metadata;
            if (FieldExists(schemaName, recordType))
                metadata = (DecimalAttributeMetadata) GetFieldMetadata(schemaName, recordType);
            else
                metadata = new DecimalAttributeMetadata();

            SetCommon(metadata, schemaName, displayName, description, isRequired, audit, searchable);

            metadata.MinValue = minimum;
            metadata.MaxValue = maximum;

            CreateOrUpdateAttribute(schemaName, recordType, metadata);
        }