示例#1
0
 public void XmlModelSerializerDisposeNullStreamTest()
 {
     _sut = new XmlModelSerializer(new MemoryStream());
     _sut.SerializationStream.Dispose();
     _sut.SerializationStream = null;
     _sut.Dispose();
 }
示例#2
0
        private static string GetCustomPropertyChar(PropertyLite propertyValue, WorkflowPropertyType propertyType)
        {
            // BluePrintSys.RC.CrossCutting.Logging.Log.Assert(
            //    (propertyValue != null) && propertyValue.SaveState.HasFlag(NodeSaveState.MemoryNode));
            if ( /*propertyValue.NodeDeleted ||*/
                (((int)PropertyTypePredefined.GroupMask & (int)propertyType.Predefined) !=
                 (int)PropertyTypePredefined.CustomGroup))
            {
                return(null);
            }
            PropertyPrimitiveType primitiveType;

            if (propertyType is NumberPropertyType)
            {
                primitiveType = PropertyPrimitiveType.Number;
            }
            else if (propertyType is DatePropertyType)
            {
                primitiveType = PropertyPrimitiveType.Date;
            }
            else if (propertyType is TextPropertyType)
            {
                primitiveType = PropertyPrimitiveType.Text;
            }
            else if (propertyType is UserPropertyType)
            {
                primitiveType = PropertyPrimitiveType.User;
            }
            else if (propertyType is ChoicePropertyType)
            {
                primitiveType = PropertyPrimitiveType.Choice;
            }
            // else if (propertyValue is DImagePropertyValue)
            // {
            //    primitiveType = PropertyPrimitiveType.Image;
            // }
            else
            {
                // BluePrintSys.RC.CrossCutting.Logging.Log.Assert(false);
                return(null);
            }
            XmlCustomProperties customProperties = new XmlCustomProperties();
            XmlCustomProperty   customProperty   = XmlCustomProperty.CreateAsValue(propertyType.PropertyTypeId,
                                                                                   (int)primitiveType);

            customProperties.CustomProperties.Add(customProperty);
            if (propertyType is ChoicePropertyType)
            {
                List <XmlCustomPropertyValidValue> validValues = customProperty.ValidValues;
                foreach (int choiceId in propertyValue.ChoiceIds)
                {
                    var customChoice = (propertyType as ChoicePropertyType).ValidValues
                                       .Where(v => v.Sid.Value == choiceId)
                                       .Select(v => v.Id).FirstOrDefault().Value;
                    XmlCustomPropertyValidValue validValue = XmlCustomPropertyValidValue.CreateAsValue(customChoice);
                    validValues.Add(validValue);
                }
            }
            return(XmlModelSerializer.SerializeCustomProperties(customProperties));
        }
示例#3
0
 public void XmlModelSerializerStreamCtorTest()
 {
     _sut = new XmlModelSerializer(new MemoryStream());
     Assert.IsNotNull(_sut);
     Assert.AreEqual(FileSystemDependency.Dependent, _sut.FileSystemDependency);
     _sut.Dispose();
 }
        public static PropertyType ConvertToPropertyType(this SqlProjectMetaRepository.PropertyTypeVersion pv)
        {
            // Property XmlInfo is not supposed to be null, see bug 4819
            var propertyFromXml = pv.PrimitiveType == PropertyPrimitiveType.Choice
                ? XmlModelSerializer.DeserializeCustomProperties(pv.XmlInfo).CustomProperties[0]
                : null;

            return(new PropertyType
            {
                Id = pv.PropertyTypeId,
                Name = pv.Name,
                VersionId = pv.VersionId,
                InstancePropertyTypeId = pv.InstancePropertyTypeId,
                PrimitiveType = pv.PrimitiveType,
                IsRichText = pv.PrimitiveType == PropertyPrimitiveType.Text ? pv.RichText : null,
                IsRequired = pv.Required,
                IsValidated = pv.PrimitiveType == PropertyPrimitiveType.Number ||
                              pv.PrimitiveType == PropertyPrimitiveType.Date ||
                              pv.PrimitiveType == PropertyPrimitiveType.Choice
                                    ? pv.Validate : null,
                IsMultipleAllowed = pv.PrimitiveType == PropertyPrimitiveType.Text ||
                                    pv.PrimitiveType == PropertyPrimitiveType.Choice
                                    ? pv.AllowMultiple : null,
                StringDefaultValue = pv.PrimitiveType == PropertyPrimitiveType.Text ? pv.StringDefaultValue : null,
                DateDefaultValue = pv.PrimitiveType == PropertyPrimitiveType.Date ? pv.DateDefaultValue : null,
                DecimalDefaultValue = pv.PrimitiveType == PropertyPrimitiveType.Number
                                      ? PropertyHelper.ToDecimal(pv.DecimalDefaultValue) : null,
                UserGroupDefaultValue = pv.PrimitiveType == PropertyPrimitiveType.User
                                      ? PropertyHelper.ParseUserGroups(pv.UserDefaultValue) : null,
                MinDate = pv.PrimitiveType == PropertyPrimitiveType.Date && pv.Validate.GetValueOrDefault() ? pv.MinDate : null,
                MaxDate = pv.PrimitiveType == PropertyPrimitiveType.Date && pv.Validate.GetValueOrDefault() ? pv.MaxDate : null,
                MinNumber = pv.PrimitiveType == PropertyPrimitiveType.Number && pv.Validate.GetValueOrDefault()
                                      ? PropertyHelper.ToDecimal(pv.MinNumber) : null,
                MaxNumber = pv.PrimitiveType == PropertyPrimitiveType.Number && pv.Validate.GetValueOrDefault()
                                      ? PropertyHelper.ToDecimal(pv.MaxNumber) : null,
                DecimalPlaces = pv.PrimitiveType == PropertyPrimitiveType.Number ? pv.DecimalPlaces : null,
                ValidValues = pv.PrimitiveType == PropertyPrimitiveType.Choice
                                      ? propertyFromXml?.ValidValues.OrderBy(v => I18NHelper.Int32ParseInvariant(v.OrderIndex))
                              .Select(v =>
                {
                    int?vvId = null;
                    if (!string.IsNullOrWhiteSpace(v.LookupListItemId))
                    {
                        int intValue;
                        if (int.TryParse(v.LookupListItemId, out intValue))
                        {
                            vvId = intValue;
                        }
                    }
                    return new ValidValue {
                        Id = vvId, Value = v.Value
                    };
                }).ToList()
                                      : null,
                DefaultValidValueId = pv.PrimitiveType == PropertyPrimitiveType.Choice
                                      ? FindDefaultValidValueId(propertyFromXml.ValidValues) // TODO
                                      : null,
            });
        }
示例#5
0
 private void Save()
 {
     if (SaveFileService.ShowDialog(Application.Current.MainWindow) == true)
     {
         using (var fileStream = new FileStream(SaveFileService.FileName, FileMode.Create))
         {
             var modelSaver = new XmlModelSerializer(fileStream);
             modelSaver.Serialize(this.Document);
         }
     }
 }
示例#6
0
 private void Load()
 {
     if (OpenFileService.ShowDialog(Application.Current.MainWindow) == true)
     {
         using (var fileStream = new FileStream(OpenFileService.FileName, FileMode.Open))
         {
             var modelSaver = new XmlModelSerializer(fileStream);
             this.Document = modelSaver.Deserialize();
         }
     }
 }
        protected override void RunInternal()
        {
            Uri universeUri   = new Uri(_client.BaseUri, "/api/universe.xml");
            Uri alliancesUri  = new Uri(_client.BaseUri, "/api/alliances.xml");
            Uri playersUri    = new Uri(_client.BaseUri, "/api/players.xml");
            Uri serverDataUri = new Uri(_client.BaseUri, "/api/serverData.xml");

            FileInfo universeFile   = new FileInfo(Path.Combine(_baseDir.FullName, _client.BaseUri.Host + "-universe.xml"));
            FileInfo alliancesFile  = new FileInfo(Path.Combine(_baseDir.FullName, _client.BaseUri.Host + "-alliances.xml"));
            FileInfo playersFile    = new FileInfo(Path.Combine(_baseDir.FullName, _client.BaseUri.Host + "-players.xml"));
            FileInfo serverDataFile = new FileInfo(Path.Combine(_baseDir.FullName, _client.BaseUri.Host + "-serverData.xml"));

            if (NeedUpdate(universeUri, universeFile, "universe").Sync())
            {
                Logger.Instance.Log(LogLevel.Info, "ApiImporterJob: Updating universe from API");

                Update(universeUri, universeFile).Sync();

                Universe model = XmlModelSerializer.Deserialize <Universe>(universeFile);
                ProcessData(model);
            }

            if (NeedUpdate(alliancesUri, alliancesFile, "alliances").Sync())
            {
                Logger.Instance.Log(LogLevel.Info, "ApiImporterJob: Updating alliances from API");

                Update(alliancesUri, alliancesFile).Sync();

                AlliancesContainer model = XmlModelSerializer.Deserialize <AlliancesContainer>(alliancesFile);
                ProcessData(model);
            }

            if (NeedUpdate(playersUri, playersFile, "players").Sync())
            {
                Logger.Instance.Log(LogLevel.Info, "ApiImporterJob: Updating players from API");

                Update(playersUri, playersFile).Sync();

                PlayersContainer model = XmlModelSerializer.Deserialize <PlayersContainer>(playersFile);
                ProcessData(model);
            }

            if (NeedUpdate(serverDataUri, serverDataFile, "serverData").Sync())
            {
                Logger.Instance.Log(LogLevel.Info, "ApiImporterJob: Updating serverData from API");

                Update(serverDataUri, serverDataFile).Sync();

                ServerData model = XmlModelSerializer.Deserialize <ServerData>(serverDataFile);
                ProcessData(model);
            }
        }
示例#8
0
        public void SetUp()
        {
            _serializationStream = new MemoryStream();
            IEnumerable <Type> knownTypes = new List <Type>
                                                (new[] { typeof(TestType), typeof(TestValue), typeof(IParent) });

            _sut = new XmlModelSerializer
            {
                SerializationStream = _serializationStream
            };
            _sut.GetType().GetField("dataContractSerializer", BindingFlags.NonPublic | BindingFlags.Instance)?.
            SetValue(_sut, new DataContractSerializer(typeof(IParent), knownTypes, 100000, false, true, null));
        }
        private Dictionary <int, List <WorkflowPropertyType> > ToItemTypePropertyTypesDictionary(IEnumerable <SqlPropertyType> sqlPropertyTypes)
        {
            var dictionary = new Dictionary <int, List <WorkflowPropertyType> >();

            foreach (var sqlPropertyType in sqlPropertyTypes)
            {
                WorkflowPropertyType workflowProperty;
                switch (sqlPropertyType.PrimitiveType)
                {
                case PropertyPrimitiveType.Text:
                {
                    workflowProperty = new TextPropertyType
                    {
                        AllowMultiple          = sqlPropertyType.AllowMultiple,
                        DefaultValidValueId    = sqlPropertyType.DefaultValidValueId,
                        InstancePropertyTypeId = GetInstancePropertyTypeId(sqlPropertyType.InstancePropertyTypeId, sqlPropertyType.Predefined),
                        Name               = sqlPropertyType.Name,
                        PropertyTypeId     = sqlPropertyType.PropertyTypeId,
                        PrimitiveType      = sqlPropertyType.PrimitiveType,
                        IsRequired         = sqlPropertyType.Required != null && sqlPropertyType.Required.Value,
                        StringDefaultValue = sqlPropertyType.StringDefaultValue,
                        VersionId          = sqlPropertyType.VersionId,
                        Predefined         = sqlPropertyType.Predefined,

                        DefaultValue = sqlPropertyType.StringDefaultValue,
                        IsValidate   = sqlPropertyType.Validate.GetValueOrDefault(false),
                        IsRichText   = sqlPropertyType.IsRichText
                    };
                    break;
                }

                case PropertyPrimitiveType.Number:
                {
                    workflowProperty = new NumberPropertyType
                    {
                        AllowMultiple          = sqlPropertyType.AllowMultiple,
                        DefaultValue           = PropertyHelper.ToDecimal((byte[])sqlPropertyType.DecimalDefaultValue),
                        DecimalPlaces          = sqlPropertyType.DecimalPlaces.GetValueOrDefault(0),
                        DefaultValidValueId    = sqlPropertyType.DefaultValidValueId,
                        InstancePropertyTypeId = sqlPropertyType.InstancePropertyTypeId,
                        Name           = sqlPropertyType.Name,
                        PropertyTypeId = sqlPropertyType.PropertyTypeId,
                        Range          = new Range <decimal>
                        {
                            End   = PropertyHelper.ToDecimal((byte[])sqlPropertyType.NumberRange_End).GetValueOrDefault(0),
                            Start = PropertyHelper.ToDecimal((byte[])sqlPropertyType.NumberRange_Start).GetValueOrDefault(0)
                        },
                        PrimitiveType = sqlPropertyType.PrimitiveType,
                        IsRequired    = sqlPropertyType.Required != null && sqlPropertyType.Required.Value,
                        IsValidate    = sqlPropertyType.Validate.GetValueOrDefault(false),
                        VersionId     = sqlPropertyType.VersionId,
                        Predefined    = sqlPropertyType.Predefined
                    };
                    break;
                }

                case PropertyPrimitiveType.Date:
                {
                    workflowProperty = new DatePropertyType
                    {
                        AllowMultiple          = sqlPropertyType.AllowMultiple,
                        DefaultValue           = sqlPropertyType.DateDefaultValue,
                        DefaultValidValueId    = sqlPropertyType.DefaultValidValueId,
                        InstancePropertyTypeId = sqlPropertyType.InstancePropertyTypeId,
                        Name           = sqlPropertyType.Name,
                        PropertyTypeId = sqlPropertyType.PropertyTypeId,
                        Range          = new Range <DateTime?>
                        {
                            End   = sqlPropertyType.DateRange_End,
                            Start = sqlPropertyType.DateRange_Start
                        },
                        PrimitiveType = sqlPropertyType.PrimitiveType,
                        IsRequired    = sqlPropertyType.Required != null && sqlPropertyType.Required.Value,
                        IsValidate    = sqlPropertyType.Validate.GetValueOrDefault(false),
                        VersionId     = sqlPropertyType.VersionId,
                        Predefined    = sqlPropertyType.Predefined
                    };
                    break;
                }

                case PropertyPrimitiveType.User:
                    workflowProperty = new UserPropertyType()
                    {
                        DefaultLabels          = sqlPropertyType.UserDefaultLabel,
                        DefaultValues          = sqlPropertyType.UserDefaultValue,
                        InstancePropertyTypeId = sqlPropertyType.InstancePropertyTypeId,
                        Name           = sqlPropertyType.Name,
                        PropertyTypeId = sqlPropertyType.PropertyTypeId,
                        PrimitiveType  = sqlPropertyType.PrimitiveType,
                        IsRequired     = sqlPropertyType.Required != null && sqlPropertyType.Required.Value,
                        VersionId      = sqlPropertyType.VersionId,
                        Predefined     = sqlPropertyType.Predefined
                    };
                    break;

                case PropertyPrimitiveType.Choice:
                {
                    workflowProperty = new ChoicePropertyType
                    {
                        AllowMultiple = sqlPropertyType.AllowMultiple,
                        // DefaultValue = PropertyHelper.ToDecimal((byte[])sqlPropertyType.DecimalDefaultValue),
                        ValidValues = XmlModelSerializer.DeserializeCustomProperties(sqlPropertyType.CustomProperty).CustomProperties[0]?.ValidValues
                                      .OrderBy(v => I18NHelper.Int32ParseInvariant(v.OrderIndex))
                                      .Select(v =>
                            {
                                int?vvId = null;
                                if (!string.IsNullOrWhiteSpace(v.LookupListItemId))
                                {
                                    int intValue;
                                    if (int.TryParse(v.LookupListItemId, out intValue))
                                    {
                                        vvId = intValue;
                                    }
                                }
                                int?vvSid = null;
                                if (!string.IsNullOrWhiteSpace(v.StandardLookupListItemId))
                                {
                                    int intValue;
                                    if (int.TryParse(v.StandardLookupListItemId, out intValue))
                                    {
                                        vvSid = intValue;
                                    }
                                }
                                return(new ValidValue {
                                    Id = vvId, Value = v.Value, Sid = vvSid
                                });
                            }).ToList(),
                        DefaultValidValueId    = sqlPropertyType.DefaultValidValueId,
                        InstancePropertyTypeId = sqlPropertyType.InstancePropertyTypeId,
                        Name           = sqlPropertyType.Name,
                        PropertyTypeId = sqlPropertyType.PropertyTypeId,
                        PrimitiveType  = sqlPropertyType.PrimitiveType,
                        IsRequired     = sqlPropertyType.Required != null && sqlPropertyType.Required.Value,
                        IsValidate     = sqlPropertyType.Validate.GetValueOrDefault(false),
                        VersionId      = sqlPropertyType.VersionId,
                        Predefined     = sqlPropertyType.Predefined
                    };
                    break;
                }

                // TODO: add other DPropertyTypes
                default:
                {
                    workflowProperty = new WorkflowPropertyType
                    {
                        AllowMultiple          = sqlPropertyType.AllowMultiple,
                        DefaultValidValueId    = sqlPropertyType.DefaultValidValueId,
                        InstancePropertyTypeId = sqlPropertyType.InstancePropertyTypeId,
                        IsRichText             = sqlPropertyType.IsRichText,
                        Name               = sqlPropertyType.Name,
                        PropertyTypeId     = sqlPropertyType.PropertyTypeId,
                        PrimitiveType      = sqlPropertyType.PrimitiveType,
                        IsRequired         = sqlPropertyType.Required != null && sqlPropertyType.Required.Value,
                        StringDefaultValue = sqlPropertyType.StringDefaultValue,
                        VersionId          = sqlPropertyType.VersionId,
                        Predefined         = sqlPropertyType.Predefined
                    };
                    break;
                }
                }

                if (dictionary.ContainsKey(sqlPropertyType.ItemTypeId))
                {
                    dictionary[sqlPropertyType.ItemTypeId].Add(workflowProperty);
                }
                else
                {
                    dictionary.Add(sqlPropertyType.ItemTypeId, new List <WorkflowPropertyType> {
                        workflowProperty
                    });
                }
            }
            return(dictionary);
        }