public void ForTypesWithoutInterfacesCustomSerializerSerializesTheSameAsDefaultSerializer(
            object instance,
            string defaultNamespace,
            Type[] extraTypes,
            string rootElementName,
            Encoding encoding,
            Formatting formatting,
            XmlSerializerNamespaces namespaces)
        {
            var defaultSerializer =
                (IXmlSerializer)Activator.CreateInstance(
                    typeof(DefaultSerializer<>).MakeGenericType(instance.GetType()),
                    defaultNamespace,
                    extraTypes,
                    rootElementName);
            var customSerializer =
                (IXmlSerializer)Activator.CreateInstance(
                    typeof(CustomSerializer<>).MakeGenericType(instance.GetType()),
                    defaultNamespace,
                    extraTypes,
                    rootElementName);

            var defaultXml = defaultSerializer.SerializeObject(instance, namespaces, encoding, formatting);
            var customXml = customSerializer.SerializeObject(instance, namespaces, encoding, formatting);

            Console.WriteLine("Default XML:");
            Console.WriteLine(defaultXml);
            Console.WriteLine();
            Console.WriteLine("Custom XML:");
            Console.WriteLine(customXml);

            Assert.That(customXml, Is.EqualTo(defaultXml));
        }
 public string ToJson(Formatting format = Formatting.None)
 {
     JsonSerializerSettings setting = new JsonSerializerSettings();
     setting.NullValueHandling = NullValueHandling.Ignore;
     string json = JsonConvert.SerializeObject(this, format, setting);
     return json;
 }
        private static string GetTagName(Formatting formatting)
        {
            switch (formatting)
            {
                case Formatting.Bold:
                    return "b";

                case Formatting.Italic:
                    return "i";

                case Formatting.Underline:
                    return "u";

                case Formatting.Strikethrough:
                    return "del";

                case Formatting.Subscript:
                    return "sub";
                
                case Formatting.Superscript:
                    return "sup";
                
                default:
                    throw new ArgumentOutOfRangeException("formatting");
            }
        }
 public DocumentWriter(Formatting formatting)
     : this(formatting,
         new JsonSerializerSettings
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver()
         })
 {
 }
 /// <summary>
 ///     To provide custom serialization using the <see cref="Newtonsoft.Json.JsonSerializer" />.
 /// </summary>
 /// <param name="configuration">The bus configuration to apply the serializer to.</param>
 /// <param name="settings">To configure serialization settings.</param>
 /// <param name="formatting">To configure serialization formatting.</param>
 /// <param name="fallbackSerializer">To add a fallback serializer (if i.e you want to support both XML and Json)</param>
 /// <returns>Bus configuration.</returns>
 public static BusBuilderConfiguration.Config WithJsonSerializer(
     this BusBuilderConfiguration.Config configuration,
     JsonSerializerSettings settings,
     Formatting formatting = Formatting.None,
     ISerializer fallbackSerializer = null)
 {
     return configuration.WithSerializer(new JsonSerializer(settings, formatting, fallbackSerializer));
 }
 public JsonNetResult(object data, 
     Formatting formatting = Formatting.None, 
     JsonSerializerSettings settings = null)
 {
     Data = data; 
     SerializerSettings = settings ?? new JsonSerializerSettings();
     Formatting = formatting;                         
 }
 public JsonNetResult(object data)
 {
     this.data = data;
     formatting = Formatting.None;
     serializerSettings = new JsonSerializerSettings
     {
         ContractResolver = new CamelCasePropertyNamesContractResolver()
     };
 }
Beispiel #8
0
 public string WriteObjectAsString(object obj, Formatting formatting = Formatting.None, TypeNameHandling nameHandling = TypeNameHandling.Auto)
 {
     return JsonConvert.SerializeObject(obj, formatting,
             new JsonSerializerSettings
             {
                 NullValueHandling = NullValueHandling.Ignore,
                 TypeNameHandling = nameHandling
             });
 }
Beispiel #9
0
 public void SaveToFile(object obj, string file, Formatting formatting = Formatting.Indented, TypeNameHandling nameHandling = TypeNameHandling.Auto)
 {
     var path = Util.Str.getFolder(file);
     if (!Directory.Exists(path))
     {
         Directory.CreateDirectory(path);
     }
     File.WriteAllText(file, WriteObjectAsString(obj, formatting, nameHandling));
 }
Beispiel #10
0
 public static string Serialize(LanguageDefinition definition, Formatting formatting, bool serializeAsArrays = false)
 {
     //var json = JsonConvert.SerializeObject(definition, formatting, new InlineDefinitionJsonConverter(), new StringDefinitionJsonConverter(serializeAsArrays));
     var settings = new JsonSerializerSettings();// {TypeNameHandling = TypeNameHandling.All};
     settings.Converters.Add(new InlineDefinitionJsonConverter(serializeAsArrays));
     settings.Converters.Add(new StringDefinitionJsonConverter(serializeAsArrays));
     var json = JsonConvert.SerializeObject(definition, formatting, settings);
     return json;
 }
Beispiel #11
0
		internal override string InternalToString(Formatting format, int depth)
		{
			if (Value != null && Value.Length > 0)
				return string.Concat("\"base64:",
					Convert.ToBase64String(this.Value),
				"\"");
			else
				return "\"base64:\"";
		}
Beispiel #12
0
 public static string SinglePage(Formatting.FormattedHtml htmlContent)
 {
     var m = new Models.SingleFileModel()
     {
         Stylesheets = new[] { htmlContent.Stylesheet },
         PreformattedHtml = htmlContent.Html,
         Javascript = new[] { htmlContent.Javascript }
     };
     return RenderSingleFile(m);
 }
        public JsonNetResult()
        {
            SerializerSettings = new JsonSerializerSettings();

            //SerializerSettings.Converters.Add(new JavaScriptDateTimeConverter());
            SerializerSettings.Converters.Add(new IsoDateTimeConverter());
            SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;
            SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
            Formatting = Formatting.None;
        }
        public JsonNetResult()
        {
            SerializerSettings = new JsonSerializerSettings();

            //SerializerSettings.Converters.Add(new JavaScriptDateTimeConverter());
            SerializerSettings.Converters.Add(new IsoDateTimeConverter());
            Formatting = Formatting.Indented;
            SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
           
               
        }
 public DocumentWriter(Formatting formatting)
     : this(
         formatting,
         new JsonSerializerSettings
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),
             DateFormatHandling = DateFormatHandling.IsoDateFormat,
             DateFormatString = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFF'Z'",
         })
 {
 }
Beispiel #16
0
        public static string ObjectToJson(this IHtmlHelper helper, object input, Formatting jsonFormatting, params JsonConverter[] converters)
        {
            JsonSerializerSettings settings = new JsonSerializerSettings();
            if (converters != null) {
                foreach (JsonConverter converter in converters) {
                    settings.Converters.Add(converter);
                }
            }

            return JsonConvert.SerializeObject(input, jsonFormatting, settings);
        }
 public CustomJsonResult()
 {
     JsonRequestBehavior = JsonRequestBehavior.AllowGet;
     JsonSerializer = new JsonSerializerSettings
     {
         Converters = new List<JsonConverter>
         {
             new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd HH:mm" }
         }
     };
     Formatting = Formatting.None;
 }
 public PlayerSaveData()
 {
     PlayerName = typeof( PlayerSaveData ).Name;
     PlayerColor = Color.green;
     EnemyColor = Color.red;
     Modules = new List<BaseUnitModule>();
     UnitDefinitions = new List<UnitDefinition>();
     Money = 1000;
     m_serializerSettings = new JsonSerializerSettings();
     m_serializerFormatting = Formatting.None;
     m_onSaveDataChanged = null;
 }
 public LayoutOptions()
 {
     this.ContainerHeaderHeight = 0.25;
     this.Padding = 0.125;
     this.ItemVerticalSpacing = 0.125;
     this.ItemHeight = 0.25;
     this.ContainerHorizontalDistance = 1.0;
     this.ItemWidth = 2.0;
     this.ContainerFormatting = new Formatting();
     this.ContainerItemFormatting = new Formatting();
     this.ContainerFormatting.TextBlockCells.VerticalAlign = "0";
 }
Beispiel #20
0
        /// <summary>
        /// Serializes the object in simple mode.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <param name="formatting">The formatting.</param>
        /// <param name="jsonSettings">The json settings.</param>
        /// <returns></returns>
        public static string SerializeObjectInSimpleMode( object value, Formatting formatting, JsonSerializerSettings jsonSettings )
        {
            JsonSerializer jsonSerializer = JsonSerializer.CreateDefault( jsonSettings );
            jsonSerializer.Formatting = formatting;

            var stringWriter = new StringWriter( new StringBuilder( 256 ), CultureInfo.InvariantCulture );
            using ( var jsonTextWriter = new Rock.Utility.RockJsonTextWriter( stringWriter, true ) )
            {
                jsonTextWriter.Formatting = jsonSerializer.Formatting;
                jsonSerializer.Serialize( jsonTextWriter, value, null );
            }
            return stringWriter.ToString();
        }
 private static JsonSerializerSettings CreateSettings(Formatting formatting, params JsonConverter[] converters)
 {
     var ret = new JsonSerializerSettings
     {
         TypeNameHandling = TypeNameHandling.Auto,
         Formatting = formatting,
         MissingMemberHandling = MissingMemberHandling.Error
     };
     foreach (var converter in converters)
     {
         ret.Converters.Add(converter);
     }
     return ret;
 }
 public static string ToJSON(EntityCollection collection, Formatting format)
 {
     var space = format == Formatting.Indented ? " " : "";
     StringBuilder sb = new StringBuilder();
     sb.Append("{" + EntitySerializer.Sep(format, 1) + "\"entities\":" + space + "[");
     List<string> entities = new List<string>();
     foreach (Entity entity in collection.Entities)
     {
         entities.Add(EntitySerializer.ToJSON(entity, format, 2));
     }
     sb.Append(string.Join(",", entities));
     sb.Append(EntitySerializer.Sep(format, 1) + "]" + EntitySerializer.Sep(format, 0) + "}");
     return sb.ToString();
 }
Beispiel #23
0
        /// <summary>Serialize an entity</summary>
        /// <param name="entity">Entity to serialize</param>
        /// <param name="formatting">Formatting, determines if indentation and line feeds are used in the file</param>
        public static string Serialize(this Entity entity, Formatting formatting)
        {
            using (var stringWriter = new StringWriter())
            {

                var serializer = new DataContractSerializer(typeof(Entity), null, int.MaxValue, false, false, null, new KnownTypesResolver());
                var writer = new XmlTextWriter(stringWriter)
                    {
                        Formatting = formatting
                    };
                serializer.WriteObject(writer, entity);
                writer.Close();
                return stringWriter.ToString();
            }
        }
        public static string ToJson(this VersionInformationEntity entity, Formatting formatting)
        {
            if (entity == null)
            {
                return string.Empty;
            }

            var settings = new JsonSerializerSettings
                {
                    PreserveReferencesHandling = PreserveReferencesHandling.None,
                    NullValueHandling = NullValueHandling.Ignore,
                    DefaultValueHandling = DefaultValueHandling.Ignore
                };

            return JsonConvert.SerializeObject(entity, formatting, settings);
        }
        public void TypeWithInterfaceSerializesSameAsTypeWithAbstract(
            object instanceWithInterface,
            object instanceWithAbstract,
            string defaultNamespace,
            Type[] extraTypes,
            string rootElementName,
            Encoding encoding,
            Formatting formatting,
            XmlSerializerNamespaces namespaces,
            IEnumerable<Tuple<string, string>> defaultXmlReplacements)
        {
            var defaultSerializer =
                new System.Xml.Serialization.XmlSerializer(
                    instanceWithAbstract.GetType(),
                    null,
                    extraTypes,
                    string.IsNullOrWhiteSpace(rootElementName) ? null : new XmlRootAttribute(rootElementName),
                    defaultNamespace);
            var customSerializer =
                (IXmlSerializerInternal)Activator.CreateInstance(
                    typeof(CustomSerializer<>).MakeGenericType(instanceWithInterface.GetType()),
                    null,
                    new TestXmlSerializerOptions
                    {
                        DefaultNamespace = defaultNamespace,
                        ExtraTypes = extraTypes,
                        RootElementName = rootElementName
                    });

            var defaultXml = defaultSerializer.SerializeObject(instanceWithAbstract, encoding, formatting, new TestSerializeOptions(namespaces)).StripXsiXsdDeclarations();
            var customXml = customSerializer.SerializeObject(instanceWithInterface, encoding, formatting, new TestSerializeOptions(namespaces)).StripXsiXsdDeclarations();

            Console.WriteLine("Default XML:");
            Console.WriteLine(defaultXml);
            Console.WriteLine();
            Console.WriteLine("Custom XML:");
            Console.WriteLine(customXml);

            if (defaultXmlReplacements != null)
            {
                defaultXml = defaultXmlReplacements.Aggregate(defaultXml, (current, replacement) => current.Replace(replacement.Item1, replacement.Item2));
            }

            Assert.That(customXml, Is.EqualTo(defaultXml));
        }
        public static string SerializeObject(object value, Formatting formatting, params JsonConverter[] converters)
        {
            var settings = new JsonSerializerSettings
            {
                PreserveReferencesHandling = PreserveReferencesHandling.None,
                TypeNameHandling = TypeNameHandling.Objects,
                ContractResolver = new EdContractResolver(),
                Binder = new EdSerializationBinder(),
                Converters = converters
            };
            var serializer = JsonSerializer.Create(settings);
            using (var writer = new JTokenWriter())
            {
                serializer.Serialize(writer, value);
                var root = (JObject)writer.Token;
                root = GraphRewriter.Deconstruct(root);

                return root.ToString(formatting);
            }
        }
        public static string SerializeObject(
            this System.Xml.Serialization.XmlSerializer serializer,
            object instance,
            Encoding encoding,
            Formatting formatting,
            ISerializeOptions options)
        {
            
            var sb = new StringBuilder();
            using (var stringWriter = new StringWriterWithEncoding(sb, encoding ?? Encoding.UTF8))
            {
                using (var xmlWriter = new XSerializerXmlTextWriter(stringWriter, options))
                {
                    xmlWriter.Formatting = formatting;
                    serializer.Serialize(xmlWriter, instance, options.Namespaces);
                }
            }

            return sb.ToString();
        }
    private static void InsertPicture(DocX doc, string filename, Formatting format)
    {
        using (MemoryStream memoryStream = new MemoryStream())
        {
            System.Drawing.Image myImg = System.Drawing.Image.FromFile(filename);

            myImg.Save(memoryStream, myImg.RawFormat);  // Save your picture in a memory stream.
            memoryStream.Seek(0, SeekOrigin.Begin);

            Novacode.Image img = doc.AddImage(memoryStream); // Create image.

            Paragraph p = doc.InsertParagraph("", false);

            Picture pic1 = img.CreatePicture();     // Create picture.

            p.InsertPicture(pic1, 0); // Insert picture into paragraph.

            doc.Save();
        }
    }
        public JsonNetFormatter()
        {
            SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
            //Settings.Converters.Add(new StringEnumConverter());
            _jSerializer = new JsonSerializer();
            _jSerializer.DateParseHandling = DateParseHandling.None;
            _jSerializer.Converters.Add(new IsoDateTimeConverter());
            //jSerializer.NullValueHandling = NullValueHandling.Ignore;

            if (File.Exists(Path.Combine(HostingEnvironment.ApplicationPhysicalPath, "App_Data", "iLoopAPISettings.txt")))
                using (var sr = new StreamReader(Path.Combine(HostingEnvironment.ApplicationPhysicalPath, "App_Data", "iLoopAPISettings.txt")))
                {
                    try
                    {
                        var settings = JsonConvert.DeserializeObject<GlobalSettings>(sr.ReadToEnd());

                        Formatting = settings.Indent ? Formatting.Indented : Formatting.None;
                        Settings.DefaultValueHandling = settings.RemoveDefaults ? DefaultValueHandling.Ignore : Settings.DefaultValueHandling;
                        Settings.NullValueHandling = settings.RemoveNulls ? NullValueHandling.Ignore : Settings.NullValueHandling;
                        Settings.DateFormatHandling = settings.UseIsoFormat ? DateFormatHandling.IsoDateFormat : Settings.DateFormatHandling;
                        Settings.ContractResolver = settings.UseCamelCase ? new CamelCasePropertyNamesContractResolver() : Settings.ContractResolver;
                        SystemConstants.TemporaryTokenExpiryTimeInMinutes = settings.TemporaryTokenExpiryTimeInMinutes;
                    }
                    catch (Exception)
                    {
                        // ignored
                    }
                }


            //JsonConvert.DefaultSettings = () => new JsonSerializerSettings
            //{
            //    Formatting = Formatting.Indented,
            //    DateFormatHandling = DateFormatHandling.IsoDateFormat,
            //    DefaultValueHandling = DefaultValueHandling.Populate,
            //    NullValueHandling = NullValueHandling.Include
            //    //ContractResolver = new CamelCasePropertyNamesContractResolver()
            //};
        }
        public void ForTypesWithoutInterfacesCustomSerializerSerializesTheSameAsDefaultSerializer(
            object instance,
            string defaultNamespace,
            Type[] extraTypes,
            string rootElementName,
            Encoding encoding,
            Formatting formatting,
            XmlSerializerNamespaces namespaces)
        {
            var defaultSerializer = 
                new System.Xml.Serialization.XmlSerializer(
                    instance.GetType(),
                    null,
                    extraTypes,
                    string.IsNullOrWhiteSpace(rootElementName) ? null : new XmlRootAttribute(rootElementName),
                    defaultNamespace);
            var customSerializer = 
                (IXmlSerializerInternal)Activator.CreateInstance(
                    typeof(CustomSerializer<>).MakeGenericType(instance.GetType()),
                    null,
                    new TestXmlSerializerOptions
                    {
                        DefaultNamespace = defaultNamespace,
                        ExtraTypes = extraTypes,
                        RootElementName = rootElementName
                    });

            var defaultXml = defaultSerializer.SerializeObject(instance, encoding, formatting, new TestSerializeOptions(namespaces)).StripXsiXsdDeclarations();
            var customXml = customSerializer.SerializeObject(instance, encoding, formatting, new TestSerializeOptions(namespaces)).StripXsiXsdDeclarations();

            Console.WriteLine("Default XML:");
            Console.WriteLine(defaultXml);
            Console.WriteLine();
            Console.WriteLine("Custom XML:");
            Console.WriteLine(customXml);

            Assert.That(customXml, Is.EqualTo(defaultXml));
        }
 public static string ToJson(ExpandoObject value, Formatting formatting = Formatting.Indented)
 {
     return(JsonConvert.SerializeObject(value, formatting, _filteredExpandoObjectConverter));
 }
 public static string ObjectToString(object obj, Formatting formatting = Formatting.Indented) => JToken.FromObject(obj, Serializer).ToString(formatting);
Beispiel #33
0
 /// <summary>
 /// Converts an object of T to a JSON string with additional Formatting and JsonSerializerSettings
 /// </summary>
 /// <example>
 /// var json = root.ToJson(settings: new JsonSerializerSettings() { ReferenceLoopHandling = ReferenceLoopHandling.Serialize });
 /// </example>
 public static string ToJson <T>(this T instance, Formatting formatting = Formatting.None,
                                 JsonSerializerSettings settings        = null) where T : class
 => JsonConvert.SerializeObject(instance, formatting, settings);
Beispiel #34
0
 /// <summary>
 ///     Serializes the specified object to a JSON string using the specified <paramref name="formatting"/>.
 /// </summary>
 /// <param name="obj">
 ///     The object to serialize.
 /// </param>
 /// <param name="formatting">
 ///     Indicates how the output is formatted.
 /// </param>
 /// <returns>
 ///     A JSON string representation of the object.
 /// </returns>
 public static string SerializeObject(Object obj, Formatting formatting = Formatting.None)
 {
     return(JsonConvert.SerializeObject(obj, formatting, SerializerSettings));
 }
        public int Run(ResultMatchSetOptions options)
        {
            int returnCode = SUCCESS;

            options.OutputFolderPath = options.OutputFolderPath ?? Path.Combine(options.FolderPath, "Out");

            ISarifLogMatcher matcher    = ResultMatchingBaselinerFactory.GetDefaultResultMatchingBaseliner();
            Formatting       formatting = options.PrettyPrint ? Formatting.Indented : Formatting.None;

            // Remove previous results.
            if (_fileSystem.DirectoryExists(options.OutputFolderPath) && options.Force)
            {
                _fileSystem.DeleteDirectory(options.OutputFolderPath, true);
            }

            // Create output folder.
            _fileSystem.CreateDirectory(options.OutputFolderPath);

            string   previousFileName = "";
            string   previousGroup = "";
            SarifLog previousLog = null, currentLog = null;

            foreach (string filePath in Directory.GetFiles(options.FolderPath, "*.sarif"))
            {
                string fileName     = Path.GetFileName(filePath);
                string currentGroup = GetGroupName(fileName);

                try
                {
                    currentLog = ReadSarifFile <SarifLog>(_fileSystem, filePath);

                    // Compare each log with the previous one in the same group.
                    if (currentGroup.Equals(previousGroup) && currentLog?.Runs?[0]?.Results.Count != 0 && previousLog?.Runs?[0]?.Results.Count != 0)
                    {
                        Console.WriteLine();
                        Console.WriteLine($"{previousFileName} -> {fileName}:");
                        SarifLog mergedLog = matcher.Match(new[] { previousLog }, new[] { currentLog }).First();

                        // Write the same and different count and different IDs.
                        WriteDifferences(mergedLog);

                        // Write the log, if there were any changed results
                        if (mergedLog.Runs[0].Results.Any(r => r.BaselineState != BaselineState.Unchanged))
                        {
                            string outputFilePath = Path.Combine(options.OutputFolderPath, fileName);

                            if (DriverUtilities.ReportWhetherOutputFileCanBeCreated(outputFilePath, options.Force, _fileSystem))
                            {
                                WriteSarifFile(_fileSystem, mergedLog, outputFilePath, formatting);
                            }
                            else
                            {
                                returnCode = FAILURE;
                            }
                        }
                    }
                }
                catch (Exception ex) when(!Debugger.IsAttached)
                {
                    Console.WriteLine(ex.ToString());
                    returnCode = FAILURE;
                }

                previousFileName = fileName;
                previousGroup    = currentGroup;
                previousLog      = currentLog;
            }

            return(returnCode);
        }
Beispiel #36
0
        public void Finish()
        {
            // Finish populating scene

            _container.materials = _materials.Values.ToList();

            _container.geometries = _geometries.Values.ToList();

            _container.obj.children = _objects.Values.ToList();

            // Serialise scene

            //using( FileStream stream
            //  = File.OpenWrite( filename ) )
            //{
            //  DataContractJsonSerializer serialiser
            //    = new DataContractJsonSerializer(
            //      typeof( Va3cContainer ) );
            //  serialiser.WriteObject( stream, _container );
            //}

            JsonSerializerSettings settings
                = new JsonSerializerSettings();

            settings.NullValueHandling
                = NullValueHandling.Ignore;

            Formatting formatting
                = UserSettings.JsonIndented
          ? Formatting.Indented
          : Formatting.None;

            myjs = JsonConvert.SerializeObject(
                _container, formatting, settings);

            File.WriteAllText(_filename, myjs);

#if USE_DYNAMIC_JSON
            // This saves the whole hassle of explicitly
            // defining a whole hierarchy of C# classes
            // to serialise to JSON - do it all on the
            // fly instead.

            // https://github.com/va3c/GHva3c/blob/master/GHva3c/GHva3c/va3c_geometry.cs

            dynamic jason = new ExpandoObject();

            //populate object properties

            jason.geometry      = new ExpandoObject();
            jason.groups        = new object[0];
            jason.material      = matName;
            jason.position      = new object[3];
            jason.position[0]   = 0; jason.position[1] = 0; jason.position[2] = 0;
            jason.rotation      = new object[3];
            jason.rotation[0]   = 0; jason.rotation[1] = 0; jason.rotation[2] = 0;
            jason.quaternion    = new object[4];
            jason.quaternion[0] = 0; jason.quaternion[1] = 0; jason.quaternion[2] = 0; jason.quaternion[3] = 0;
            jason.scale         = new object[3];
            jason.scale[0]      = 1; jason.scale[1] = 1; jason.scale[2] = 1;
            jason.visible       = true;
            jason.castShadow    = true;
            jason.receiveShadow = false;
            jason.doubleSided   = true;


            //populate geometry object
            jason.geometry.metadata              = new ExpandoObject();
            jason.geometry.metadata.version      = 3.1;
            jason.geometry.metadata.generatedBy  = "RvtVa3c Revit va3c exporter";
            jason.geometry.metadata.vertices     = mesh.Vertices.Count;
            jason.geometry.metadata.faces        = mesh.Faces.Count;
            jason.geometry.metadata.normals      = 0;
            jason.geometry.metadata.colors       = 0;
            jason.geometry.metadata.uvs          = 0;
            jason.geometry.metadata.materials    = 0;
            jason.geometry.metadata.morphTargets = 0;
            jason.geometry.metadata.bones        = 0;

            jason.geometry.scale        = 1.000;
            jason.geometry.materials    = new object[0];
            jason.geometry.vertices     = new object[mesh.Vertices.Count * 3];
            jason.geometry.morphTargets = new object[0];
            jason.geometry.normals      = new object[0];
            jason.geometry.colors       = new object[0];
            jason.geometry.uvs          = new object[0];
            jason.geometry.faces        = new object[mesh.Faces.Count * 3];
            jason.geometry.bones        = new object[0];
            jason.geometry.skinIndices  = new object[0];
            jason.geometry.skinWeights  = new object[0];
            jason.geometry.animation    = new ExpandoObject();

            //populate vertices
            int counter = 0;
            int i       = 0;
            foreach (var v in mesh.Vertices)
            {
                jason.geometry.vertices[counter++] = mesh.Vertices[i].X;
                jason.geometry.vertices[counter++] = mesh.Vertices[i].Y;
                jason.geometry.vertices[counter++] = mesh.Vertices[i].Z;
                i++;
            }

            //populate faces
            counter = 0;
            i       = 0;
            foreach (var f in mesh.Faces)
            {
                jason.geometry.faces[counter++] = mesh.Faces[i].A;
                jason.geometry.faces[counter++] = mesh.Faces[i].B;
                jason.geometry.faces[counter++] = mesh.Faces[i].C;
                i++;
            }

            return(JsonConvert.SerializeObject(jason));
#endif // USE_DYNAMIC_JSON
        }
Beispiel #37
0
        public Artifact(List <Property> properties, World world)
            : base(properties, world)
        {
            Name = "Untitled";
            Type = "Unknown";
            WrittenContentIds = new List <int>();

            foreach (Property property in properties)
            {
                switch (property.Name)
                {
                case "name": Name = Formatting.InitCaps(property.Value); break;

                case "item":
                    if (property.SubProperties != null)
                    {
                        property.Known = true;
                        foreach (Property subProperty in property.SubProperties)
                        {
                            switch (subProperty.Name)
                            {
                            case "name_string":
                                Item = string.Intern(Formatting.InitCaps(subProperty.Value));
                                break;

                            case "page_number":
                                PageCount = Convert.ToInt32(subProperty.Value);
                                break;

                            case "page_written_content_id":
                            case "writing_written_content_id":
                                if (!WrittenContentIds.Contains(Convert.ToInt32(subProperty.Value)))
                                {
                                    WrittenContentIds.Add(Convert.ToInt32(subProperty.Value));
                                }
                                break;
                            }
                        }
                    }
                    else
                    {
                        Item = Formatting.InitCaps(property.Value);
                    }
                    break;

                case "item_type": Type = string.Intern(Formatting.InitCaps(property.Value)); break;

                case "item_subtype": SubType = string.Intern(property.Value); break;

                case "item_description": Description = Formatting.InitCaps(property.Value); break;

                case "mat": Material = string.Intern(property.Value); break;

                case "page_count": PageCount = Convert.ToInt32(property.Value); break;

                case "abs_tile_x": AbsTileX = Convert.ToInt32(property.Value); break;

                case "abs_tile_y": AbsTileY = Convert.ToInt32(property.Value); break;

                case "abs_tile_z": AbsTileZ = Convert.ToInt32(property.Value); break;

                case "writing": if (!WrittenContentIds.Contains(Convert.ToInt32(property.Value)))
                    {
                        WrittenContentIds.Add(Convert.ToInt32(property.Value));
                    }
                    break;

                case "site_id":
                    Site = world.GetSite(Convert.ToInt32(property.Value));
                    break;

                case "subregion_id":
                    Region = world.GetRegion(Convert.ToInt32(property.Value));
                    break;

                case "holder_hfid":
                    HolderId = Convert.ToInt32(property.Value);
                    break;

                case "structure_local_id":
                    Structure = Site?.Structures.FirstOrDefault(structure => structure.Id == Convert.ToInt32(property.Value));
                    break;
                }
            }
            if (AbsTileX > 0 && AbsTileY > 0)
            {
                Coordinates = new Location(AbsTileX / 816, AbsTileY / 816);
            }
            else if (Site != null)
            {
                Coordinates = Site.Coordinates;
            }
        }
Beispiel #38
0
 public static string SerializeObject(object?value, Formatting formatting, JsonSerializerSettings?settings)
 {
     return(SerializeObject(value, null, formatting, settings));
 }
Beispiel #39
0
        /// <summary>
        /// Serializes the <see cref="XmlNode"/> to a JSON string using formatting.
        /// </summary>
        /// <param name="node">The node to serialize.</param>
        /// <param name="formatting">Indicates how the output should be formatted.</param>
        /// <returns>A JSON string of the <see cref="XmlNode"/>.</returns>
        public static string SerializeXmlNode(XmlNode?node, Formatting formatting)
        {
            XmlNodeConverter converter = new XmlNodeConverter();

            return(SerializeObject(node, formatting, converter));
        }
 public DocumentWriter(Formatting formatting, JsonSerializerSettings settings)
 {
     _serializer            = JsonSerializer.CreateDefault(settings);
     _serializer.Formatting = formatting;
 }
Beispiel #41
0
 /// <summary>
 /// 将一个 <see cref="System.Object"/> 对象序列化转换为 JSON 格式字符串。
 /// </summary>
 /// <param name="_this">要序列化的对象。</param>
 /// <param name="type">定义序列化对象的转换类型。</param>
 /// <param name="formatting">定义序列化结果的输出格式。</param>
 /// <param name="settings">定义序列化对象时采用的序列化设置。</param>
 /// <returns>序列化的 JSON 字符串。</returns>
 /// <remarks>该方法调用 Newtonsoft.Json.dll 组件的 JsonConvert.SerializeObject 方法来执行序列化操作。</remarks>
 public static string ToJson(this object _this, Type type, Formatting formatting, JsonSerializerSettings settings)
 {
     return(JsonSerializer.Serialize(_this, type, formatting, settings));
 }
Beispiel #42
0
 /// <summary>
 /// 将一个 <see cref="System.Object"/> 对象序列化转换为 JSON 格式字符串。
 /// </summary>
 /// <param name="_this">要序列化的对象。</param>
 /// <param name="formatting">定义序列化结果的输出格式。</param>
 /// <param name="converters">定义序列化对象时的转换器集合。</param>
 /// <returns>序列化的 JSON 字符串。</returns>
 /// <remarks>该方法调用 Newtonsoft.Json.dll 组件的 JsonConvert.SerializeObject 方法来执行序列化操作。</remarks>
 public static string ToJson(this object _this, Formatting formatting, params JsonConverter[] converters)
 {
     return(JsonSerializer.Serialize(_this, formatting, converters));
 }
Beispiel #43
0
        public static bool WriteProtocol(IEnumerable <Protocol> people, string nameFile, DateTime from, DateTime to)
        {
            try
            {
                var doc = DocX.Create(nameFile);

                doc.PageLayout.Orientation = Novacode.Orientation.Landscape;
                doc.MarginTop    = 20;
                doc.MarginLeft   = 20;
                doc.MarginRight  = 20;
                doc.MarginBottom = 20;

                var header = new Formatting();
                header.FontFamily = new System.Drawing.FontFamily("Times New Roman");
                header.Size       = 16;
                header.Bold       = true;

                var titleName = new Formatting();
                titleName.FontFamily = new System.Drawing.FontFamily("Times New Roman");
                titleName.Size       = 11;

                var contenttext = new Formatting();
                contenttext.FontFamily = new System.Drawing.FontFamily("Times New Roman");
                contenttext.Size       = 9D;

                doc.InsertParagraph("Протокол тестування ", false, header).Alignment = Alignment.center;
                doc.InsertParagraph(string.Format("Період проведення з {0} до {1}", from.ToString("dd-MM-yyyy"), to.ToString("dd-MM-yyyy")), false, titleName).Alignment = Alignment.left;

                Table table = doc.AddTable(people.Count() + 1, 10);

                table.Rows[0].Cells[0].Paragraphs.First().Append(" № ");
                table.Rows[0].Cells[1].Paragraphs.First().Append("Прізвище");
                table.Rows[0].Cells[2].Paragraphs.First().Append("Таб. ном.");
                table.Rows[0].Cells[3].Paragraphs.First().Append("Білет");
                table.Rows[0].Cells[4].Paragraphs.First().Append("Дата");
                table.Rows[0].Cells[5].Paragraphs.First().Append("На комп'ютері");
                table.Rows[0].Cells[6].Paragraphs.First().Append("Клас       ");
                table.Rows[0].Cells[7].Paragraphs.First().Append("Відповіді");
                table.Rows[0].Cells[8].Paragraphs.First().Append("Помилки");
                table.Rows[0].Cells[9].Paragraphs.First().Append("Результат");

                List <Protocol> people_ = people.ToList();

                for (int z = 0; z < people_.Count(); z++)
                {
                    table.Rows[z + 1].Cells[0].Paragraphs.First().Append((z + 1).ToString());
                    table.Rows[z + 1].Cells[1].Paragraphs.First().Append(people_[z].ticket.user.Lname);
                    table.Rows[z + 1].Cells[2].Paragraphs.First().Append(people_[z].ticket.user.ID.ToString());
                    table.Rows[z + 1].Cells[3].Paragraphs.First().Append(people_[z].ticket.ID.ToString());
                    table.Rows[z + 1].Cells[4].Paragraphs.First().Append(people_[z].ticket.date.ToString("dd-MM-yyyy"));
                    table.Rows[z + 1].Cells[5].Paragraphs.First().Append(people_[z].ticket.IsOffline.Equals("ні")?"так": "ні");
                    table.Rows[z + 1].Cells[6].Paragraphs.First().Append(people_[z].ticket.level);
                    table.Rows[z + 1].Cells[7].Paragraphs.First().Append(people_[z].answers.ToString());
                    table.Rows[z + 1].Cells[8].Paragraphs.First().Append(people_[z].errors.ToString());
                    table.Rows[z + 1].Cells[9].Paragraphs.First().Append(people_[z].ticket.IsPassed);

                    if (people_[z].ticket.IsPassed.Equals("ні"))
                    {
                        for (int i = 0; i < 10; i++)
                        {
                            table.Rows[z + 1].Cells[i].FillColor = System.Drawing.Color.OrangeRed;
                        }
                    }
                }

                doc.InsertTable(table);
                doc.InsertParagraph("");
                doc.InsertParagraph("");
                doc.InsertParagraph(@"Підпис членів комісії  ________________________________________________________
                                       ________________________________________________________
                                       ________________________________________________________", false, contenttext).Alignment = Alignment.left;
                doc.Save();

                return(true);
            }
            catch (Exception ex)
            {
                throw new Exception("WriteTicketToWord " + ex.Message);
            }
        }
 public override string ToString() => $"Enum.Parse(typeof({Formatting.FriendlyName(typeof(TValue))}), <arg>)";
Beispiel #45
0
        protected override void LoadKernelDefaultConfigurationDataObjects(TransactionTypeEnum transactionTypeEnum, IConfigurationProvider configProvider)
        {
            Logger.Log("Using Global Kernel 3 Values:");
            Kernel3Configuration = XMLUtil <Kernel3Configuration> .Deserialize(configProvider.GetKernel3GlobalConfigurationDataXML());

            #region 3.3.4.2 and 3.3.4.3
            TERMINAL_TRANSACTION_QUALIFIERS_9F66_KRN ttq = new TERMINAL_TRANSACTION_QUALIFIERS_9F66_KRN(this);
            if (Kernel3Configuration.FDDAForOnlineSupported)
            {
                ttq.Value.OfflineDataAuthenticationForOnlineAuthorizationsSupported = true;
            }
            else
            {
                ttq.Value.OfflineDataAuthenticationForOnlineAuthorizationsSupported = false;
            }
            #endregion

            Logger.Log("Using Kernel 3 Defaults:");
            KernelConfigurationDataForTransactionType kcdott = new KernelConfigurationDataForTransactionType()
            {
                TransactionTypeEnum            = transactionTypeEnum,
                KernelConfigurationDataObjects = TLVListXML.XmlDeserialize(configProvider.GetKernel3ConfigurationDataXML(Formatting.ByteArrayToHexString(new byte[] { (byte)transactionTypeEnum })))
            };

            int depth = 0;
            Logger.Log("Transaction Type: " + transactionTypeEnum + " Using Kernel3 Defaults: \n" + kcdott.KernelConfigurationDataObjects.ToPrintString(ref depth));

            KernelConfigurationData.Add(kcdott);
        }
Beispiel #46
0
 public static string SerializeObject(object?value, Formatting formatting)
 {
     return(SerializeObject(value, formatting, (JsonSerializerSettings?)null));
 }
Beispiel #47
0
        public async Task <bool> Process(string[] args)
        {
            try
            {
                ArgumentSyntax.Parse(args, syntax =>
                {
                    syntax.HandleErrors  = false;
                    registerOptions      = DefineRegisterCommand(syntax);
                    authorizationOptions = DefineAuthorizationCommand(syntax);
                    certificateOptions   = DefineCertificateCommand(syntax);
                });
            }
            catch (ArgumentSyntaxException ex)
            {
                consoleLogger.Error(ex.Message);
            }

            jsonSettings = new JsonSerializerSettings
            {
                ContractResolver  = new CamelCasePropertyNamesContractResolver(),
                NullValueHandling = NullValueHandling.Ignore
            };

            jsonSettings.Converters.Add(new StringEnumConverter());

#if DEBUG
            formatting = Formatting.Indented;
#endif

            try
            {
                switch (command)
                {
                case Command.Register:
                    await this.ProcessCommand <RegisterCommand, RegisterOptions>(new RegisterCommand(registerOptions, this.consoleLogger));

                    break;

                case Command.Authorization:
                    await this.ProcessCommand <AuthorizationCommand, AuthorizationOptions>(new AuthorizationCommand(authorizationOptions, this.consoleLogger));

                    break;

                case Command.Certificate:
                    await this.ProcessCommand <CertificateCommand, CertificateOptions>(new CertificateCommand(certificateOptions, this.consoleLogger));

                    break;
                }

                return(true);
            }
            catch (AggregateException ex)
            {
                foreach (var err in ex.InnerExceptions)
                {
                    consoleLogger.Error(err, err.Message);
                }
            }
            catch (Exception ex)
            {
                consoleLogger.Error(ex, ex.Message);
            }

            return(false);
        }
Beispiel #48
0
 /// <summary>
 /// Serializes the <see cref="XNode"/> to a JSON string using formatting.
 /// </summary>
 /// <param name="node">The node to convert to JSON.</param>
 /// <param name="formatting">Indicates how the output should be formatted.</param>
 /// <returns>A JSON string of the <see cref="XNode"/>.</returns>
 public static string SerializeXNode(XObject?node, Formatting formatting)
 {
     return(SerializeXNode(node, formatting, false));
 }
 public SerializerSettings(DateFormatHandling dateFormat = DateFormatHandling.MicrosoftDateFormat, Formatting formatting = Formatting.None)
 {
     Formatting = formatting;
     DateFormat = dateFormat;
 }
Beispiel #50
0
        public HistoricalFigure(List <Property> properties, World world)
            : base(properties, world)
        {
            Initialize();
            foreach (Property property in properties)
            {
                switch (property.Name)
                {
                case "appeared": Appeared = Convert.ToInt32(property.Value); break;

                case "birth_year": BirthYear = Convert.ToInt32(property.Value); break;

                case "birth_seconds72": BirthSeconds72 = Convert.ToInt32(property.Value); break;

                case "death_year": DeathYear = Convert.ToInt32(property.Value); break;

                case "death_seconds72": DeathSeconds72 = Convert.ToInt32(property.Value); break;

                case "name": Name = Formatting.InitCaps(property.Value.Replace("'", "`")); break;

                case "race": Race = world.GetCreatureInfo(property.Value); break;

                case "caste": Caste = string.Intern(Formatting.InitCaps(property.Value.ToLower().Replace('_', ' '))); break;

                case "associated_type": AssociatedType = string.Intern(Formatting.InitCaps(property.Value.ToLower().Replace('_', ' '))); break;

                case "deity": Deity = true; property.Known = true; break;

                case "skeleton": Skeleton = true; property.Known = true; break;

                case "force": Force = true; property.Known = true; Race = world.GetCreatureInfo("Force"); break;

                case "zombie": Zombie = true; property.Known = true; break;

                case "ghost": Ghost = true; property.Known = true; break;

                case "hf_link":     //Will be processed after all HFs have been loaded
                    world.AddHFtoHfLink(this, property);
                    property.Known = true;
                    List <string> knownSubProperties = new List <string> {
                        "hfid", "link_strength", "link_type"
                    };
                    if (property.SubProperties != null)
                    {
                        foreach (string subPropertyName in knownSubProperties)
                        {
                            Property subProperty = property.SubProperties.FirstOrDefault(property1 => property1.Name == subPropertyName);
                            if (subProperty != null)
                            {
                                subProperty.Known = true;
                            }
                        }
                    }

                    break;

                case "entity_link":
                case "entity_former_position_link":
                case "entity_position_link":
                    world.AddHFtoEntityLink(this, property);
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        foreach (string subPropertyName in KnownEntitySubProperties)
                        {
                            Property subProperty = property.SubProperties.FirstOrDefault(property1 => property1.Name == subPropertyName);
                            if (subProperty != null)
                            {
                                subProperty.Known = true;
                            }
                        }
                    }

                    break;

                case "entity_reputation":
                    world.AddReputation(this, property);
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        foreach (string subPropertyName in Reputation.KnownReputationSubProperties)
                        {
                            Property subProperty = property.SubProperties.FirstOrDefault(property1 => property1.Name == subPropertyName);
                            if (subProperty != null)
                            {
                                subProperty.Known = true;
                            }
                        }
                    }

                    break;

                case "entity_squad_link":
                case "entity_former_squad_link":
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        foreach (string subPropertyName in KnownEntitySquadLinkProperties)
                        {
                            Property subProperty = property.SubProperties.FirstOrDefault(property1 => property1.Name == subPropertyName);
                            if (subProperty != null)
                            {
                                subProperty.Known = true;
                            }
                        }
                    }

                    break;

                case "relationship_profile_hf":
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        RelationshipProfiles.Add(new RelationshipProfileHf(property.SubProperties, RelationShipProfileType.Unknown));
                    }
                    break;

                case "relationship_profile_hf_visual":
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        RelationshipProfiles.Add(new RelationshipProfileHf(property.SubProperties, RelationShipProfileType.Visual));
                    }
                    break;

                case "relationship_profile_hf_historical":
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        RelationshipProfiles.Add(new RelationshipProfileHf(property.SubProperties, RelationShipProfileType.Historical));
                    }
                    break;

                case "site_link":
                    world.AddHFtoSiteLink(this, property);
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        foreach (string subPropertyName in KnownSiteLinkSubProperties)
                        {
                            Property subProperty = property.SubProperties.FirstOrDefault(property1 => property1.Name == subPropertyName);
                            if (subProperty != null)
                            {
                                subProperty.Known = true;
                            }
                        }
                    }

                    break;

                case "hf_skill":
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        var skill = new Skill(property.SubProperties);
                        Skills.Add(skill);
                    }
                    break;

                case "active_interaction": ActiveInteractions.Add(string.Intern(property.Value)); break;

                case "interaction_knowledge": InteractionKnowledge.Add(string.Intern(property.Value)); break;

                case "animated": Animated = true; property.Known = true; break;

                case "animated_string": if (AnimatedType != "")
                    {
                        throw new Exception("Animated Type already exists.");
                    }
                    AnimatedType = Formatting.InitCaps(property.Value); break;

                case "journey_pet": JourneyPets.Add(Formatting.FormatRace(property.Value)); break;

                case "goal": Goal = Formatting.InitCaps(property.Value); break;

                case "sphere": Spheres.Add(property.Value); break;

                case "current_identity_id": CurrentIdentityId = Convert.ToInt32(property.Value); break;

                case "used_identity_id": UsedIdentityIds.Add(Convert.ToInt32(property.Value)); break;

                case "ent_pop_id": EntityPopulationId = Convert.ToInt32(property.Value); break;

                case "holds_artifact":
                    var artifact = world.GetArtifact(Convert.ToInt32(property.Value));
                    HoldingArtifacts.Add(artifact);
                    artifact.Holder = this;
                    break;

                case "adventurer":
                    Adventurer     = true;
                    property.Known = true;
                    break;

                case "breed_id":
                    BreedId = property.Value;
                    if (!string.IsNullOrWhiteSpace(BreedId))
                    {
                        if (world.Breeds.ContainsKey(BreedId))
                        {
                            world.Breeds[BreedId].Add(this);
                        }
                        else
                        {
                            world.Breeds.Add(BreedId, new List <HistoricalFigure> {
                                this
                            });
                        }
                    }
                    break;

                case "sex": property.Known = true; break;

                case "site_property":
                    // is resolved in SiteProperty.Resolve()
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        foreach (Property subProperty in property.SubProperties)
                        {
                            switch (subProperty.Name)
                            {
                            case "site_id": subProperty.Known = true; break;

                            case "property_id": subProperty.Known = true; break;
                            }
                        }
                    }
                    break;

                case "vague_relationship":
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        VagueRelationships.Add(new VagueRelationship(property.SubProperties));
                    }
                    break;

                case "honor_entity":
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        HonorEntity = new HonorEntity(property.SubProperties, world);
                    }
                    break;

                case "intrigue_actor":
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        IntrigueActors.Add(new IntrigueActor(property.SubProperties));
                    }
                    break;

                case "intrigue_plot":
                    property.Known = true;
                    if (property.SubProperties != null)
                    {
                        IntriguePlots.Add(new IntriguePlot(property.SubProperties));
                    }
                    break;
                }
            }

            if (string.IsNullOrWhiteSpace(Name))
            {
                Name = !string.IsNullOrWhiteSpace(AnimatedType) ? Formatting.InitCaps(AnimatedType) : "(Unnamed)";
            }
            if (Adventurer)
            {
                world.AddPlayerRelatedDwarfObjects(this);
            }
        }
Beispiel #51
0
        public void createDocument(string fileName, string txt, int scene)
        {
            // CREATING DOCX FILE, TO RECORD THE USER STORY
            string pathFileName = @"C:/Users/parad/Desktop/StoryTelling1/StoryTelling1/bin/Debug/" + fileName;
            string headlineText = "Defend Your Kingdom \n Your Interactive Storytelling";
            string paraOne      = "" + txt;

            // A formatting object for our normal paragraph text:
            var paraScene = new Formatting();

            paraScene.FontFamily = new System.Drawing.FontFamily("Calibri");
            paraScene.Size       = 9D;
            paraScene.Bold       = true;

            //Console.WriteLine("HERE ---- " + pathFileName + " || " + paraOne);

            //string curFile = @"c:\temp\test.txt";  //Your path
            if (!File.Exists(pathFileName))
            {
                Console.WriteLine("Docx -- " + pathFileName);
                // A formatting object for our headline:
                var headLineFormat = new Formatting();
                headLineFormat.FontFamily = new System.Drawing.FontFamily("Arial Black");
                headLineFormat.Size       = 14D;
                headLineFormat.Position   = 12;
                headLineFormat.FontColor  = System.Drawing.Color.Green;

                // Create the document in memory:
                var doc = DocX.Create(fileName);

                // A formatting object for our normal paragraph text:
                var paraFormat = new Formatting();
                paraFormat.FontFamily = new System.Drawing.FontFamily("Calibri");
                paraFormat.Size       = 9D;

                Paragraph title = doc.InsertParagraph(headlineText, false, headLineFormat);
                title.Alignment = Alignment.center;

                Paragraph scenes = doc.InsertParagraph("Scene " + scene, false, paraScene);
                scenes.Alignment = Alignment.left;

                Paragraph texts = doc.InsertParagraph(paraOne, false, paraFormat);

                // Save to the output directory:
                doc.Save();
            }
            else
            {
                // Create the document in memory:
                using (DocX doc = DocX.Load(@fileName))
                {
                    doc.ReplaceText("Novacode.DocX", "", true, RegexOptions.IgnoreCase);

                    doc.InsertParagraph(Environment.NewLine);

                    //string docText = doc.ToString() + txt;

                    var paraFormat = new Formatting();
                    paraFormat.FontFamily = new System.Drawing.FontFamily("Calibri");
                    paraFormat.Size       = 9D;

                    Paragraph scenes = doc.InsertParagraph("Scene " + scene, false, paraScene);
                    scenes.Alignment = Alignment.left;

                    //doc.InsertParagraph(docText, false, paraFormat);
                    doc.InsertParagraph(txt, false, paraFormat);

                    // Save to the output directory:
                    doc.Save();
                }
            }
        }
 public string SerializeObject(object o, Formatting f)
 {
     return(JsonConvert.SerializeObject(o, f, _converter));
 }
Beispiel #53
0
        public static string SerializeToAnonymousObject(this object o, string indentation = "\t\t\t\t", Formatting format = Formatting.Indented)
        {
            if (o is string)
            {
                return(o.ToString().SurroundWithQuotes());
            }

            var serializer = new JsonSerializer()
            {
                Formatting = format
            };
            var stringWriter = new StringWriter();
            var writer       = new JsonTextWriter(stringWriter);

            writer.QuoteName = false;
            serializer.Serialize(writer, o);
            writer.Close();
            //anonymousify the json
            var anon = stringWriter.ToString()
                       .Replace("{", "new {")
                       .Replace("]", "}")
                       .Replace("[", "new [] {")
                       .Replace(":", "=")
                       .Replace("http=", "http:");

            //match indentation of the view
            anon = Regex.Replace(anon, @"^(\s+)?", (m) =>
            {
                if (m.Index == 0)
                {
                    return(m.Value);
                }
                return("\t\t\t\t" + m.Value.Replace("  ", "\t"));
            }, RegexOptions.Multiline);
            //escape c# keywords in the anon object
            anon = anon.Replace("default=", "@default=").Replace("params=", "@params=");
            //docs contain different types of anon objects, quick fix by making them a dynamic[]
            anon = anon.Replace("docs= new []", "docs= new dynamic[]");
            //fix empty untyped arrays, default to string
            anon = Regex.Replace(anon, @"new \[\] \{[\s\t\r\n]*\}", "new string[] {}");
            //quick fixes for settings: index.* and discovery.zen.*
            //needs some recursive regex love perhaps in the future
            anon = Regex.Replace(anon, @"(index|discovery)\.([^=]+)=([^\r\n,]+)", " { \"$1.$2\", $3 }", RegexOptions.Multiline);
            anon = Regex.Replace(anon, @"new \{(\r\n\s+\{ "")(index|discovery)", "new Dictionary<string, object> {$1$2", RegexOptions.Multiline);
            return(anon);
        }
Beispiel #54
0
        public override string ToPrintString()
        {
            string        header = "Start ADPU Request: " + this.GetType().Name;
            string        body   = "P1: " + Formatting.ByteArrayToHexString(new byte[] { P1 }) + " P2: " + Formatting.ByteArrayToHexString(new byte[] { P2 });
            string        footer = "End ADPU Request: " + this.GetType().Name;
            StringBuilder sb     = new StringBuilder();

            sb.AppendLine(header).AppendLine(body).Append(footer);
            return(sb.ToString());
        }
Beispiel #55
0
 public static string ToJson(this object value, Formatting formatting = Formatting.None)
 {
     return(JsonConvert.SerializeObject(value, formatting));
 }
Beispiel #56
0
 /// <summary>
 /// Outgoing objects will be serialized into a JSON wrapper object using the Newtonsoft.Json library
 /// </summary>
 /// <param name="builder"></param>
 /// <param name="formatting"></param>
 /// <returns></returns>
 public static IHypermediaResolverBuilder WithSingleNewtonsoftJsonObjectParameterSerializer(this IHypermediaResolverBuilder builder, Formatting formatting = Formatting.None)
 {
     return(builder.WithCustomParameterSerializer(() => new SingleNewtonsoftJsonObjectParameterSerializer(formatting)));
 }
Beispiel #57
0
 public override void Table(string tableName)
 {
     base.Table(Formatting.Pluralize(tableName));
 }
Beispiel #58
0
        public ChangeHfState(List <Property> properties, World world)
            : base(properties, world)
        {
            foreach (Property property in properties)
            {
                switch (property.Name)
                {
                case "state":
                    switch (property.Value)
                    {
                    case "settled": State = HfState.Settled; break;

                    case "wandering": State = HfState.Wandering; break;

                    case "scouting": State = HfState.Scouting; break;

                    case "snatcher": State = HfState.Snatcher; break;

                    case "refugee": State = HfState.Refugee; break;

                    case "thief": State = HfState.Thief; break;

                    case "hunting": State = HfState.Hunting; break;

                    case "visiting": State = HfState.Visiting; break;

                    default: State = HfState.Unknown; property.Known = false; break;
                    }
                    break;

                case "substate": SubState = Convert.ToInt32(property.Value); break;

                case "coords": Coordinates = Formatting.ConvertToLocation(property.Value); break;

                case "hfid": HistoricalFigure = world.GetHistoricalFigure(Convert.ToInt32(property.Value)); break;

                case "site_id": Site = world.GetSite(Convert.ToInt32(property.Value)); break;

                case "subregion_id": Region = world.GetRegion(Convert.ToInt32(property.Value)); break;

                case "feature_layer_id": UndergroundRegion = world.GetUndergroundRegion(Convert.ToInt32(property.Value)); break;

                case "site": Site = world.GetSite(Convert.ToInt32(property.Value)); break;

                case "mood":
                    switch (property.Value)
                    {
                    case "macabre":
                        Mood = Mood.Macabre;
                        break;

                    case "secretive":
                        Mood = Mood.Secretive;
                        break;

                    case "insane":
                        Mood = Mood.Insane;
                        break;

                    case "possessed":
                        Mood = Mood.Possessed;
                        break;

                    case "berserk":
                        Mood = Mood.Berserk;
                        break;

                    case "fey":
                        Mood = Mood.Fey;
                        break;

                    case "melancholy":
                        Mood = Mood.Melancholy;
                        break;

                    case "fell":
                        Mood = Mood.Fell;
                        break;

                    case "catatonic":
                        Mood = Mood.Catatonic;
                        break;

                    default:
                        Mood           = Mood.Unknown;
                        property.Known = false;
                        break;
                    }
                    break;

                case "reason":
                    switch (property.Value)
                    {
                    case "failed mood":
                        Reason = ChangeHfStateReason.FailedMood;
                        break;

                    case "gather information":
                        Reason = ChangeHfStateReason.GatherInformation;
                        break;

                    case "be with master":
                        Reason = ChangeHfStateReason.BeWithMaster;
                        break;

                    case "flight":
                        Reason = ChangeHfStateReason.Flight;
                        break;

                    case "scholarship":
                        Reason = ChangeHfStateReason.Scholarship;
                        break;

                    case "on a pilgrimage":
                        Reason = ChangeHfStateReason.Pilgrimage;
                        break;

                    case "lack of sleep":
                        Reason = ChangeHfStateReason.LackOfSleep;
                        break;

                    case "great deal of stress":
                        Reason = ChangeHfStateReason.GreatDealOfStress;
                        break;

                    default:
                        if (property.Value != "-1")
                        {
                            property.Known = false;
                        }
                        break;
                    }
                    break;
                }
            }
            if (HistoricalFigure != null)
            {
                HistoricalFigure.AddEvent(this);
                HistoricalFigure.States.Add(new HistoricalFigure.State(State, Year));
                HistoricalFigure.State lastState = HistoricalFigure.States.LastOrDefault();
                if (lastState != null)
                {
                    lastState.EndYear = Year;
                }

                HistoricalFigure.CurrentState = State;
            }
            Site.AddEvent(this);
            Region.AddEvent(this);
            UndergroundRegion.AddEvent(this);
        }
Beispiel #59
0
        public bool WriteTicketToWord(IDictionary <QuestionInfo, IEnumerable <AnswerInfo> > ticket, UserInfo user, int ticketID, string namefile)
        {
            try
            {
                var doc = DocX.Create(namefile);

                doc.MarginTop    = 20;
                doc.MarginLeft   = 20;
                doc.MarginRight  = 20;
                doc.MarginBottom = 20;


                var header = new Formatting();
                header.FontFamily = new System.Drawing.FontFamily("Times New Roman");
                header.Size       = 16;
                header.Bold       = true;

                var titleName = new Formatting();
                titleName.FontFamily = new System.Drawing.FontFamily("Times New Roman");
                titleName.Size       = 11;

                var titleQuestion = new Formatting();
                titleQuestion.FontFamily = new System.Drawing.FontFamily("Times New Roman");
                titleQuestion.Size       = 9;
                titleQuestion.Bold       = true;

                var titleInfo = new Formatting();
                titleInfo.FontFamily = new System.Drawing.FontFamily("Times New Roman");
                titleInfo.Size       = 9D;
                titleInfo.Italic     = true;

                var contenttext = new Formatting();
                contenttext.FontFamily = new System.Drawing.FontFamily("Times New Roman");
                contenttext.Size       = 9D;

                doc.InsertParagraph("Тест для підвищення / пониження класності водіям та розрядів машиністам " + ticket.First().Key.Level, false, header).Alignment = Alignment.center;
                doc.InsertParagraph(string.Format("Іспит складає {0} {1}\tТаб. № {2}", PrepareString(user.Fname), PrepareString(user.Lname), new string('_', 20)), false, titleName).Alignment = Alignment.left;
                doc.InsertParagraph(DateTime.Now.ToString(), false, titleName).Alignment = Alignment.left;
                doc.InsertParagraph("Білет № " + ticketID, false, titleName).Alignment   = Alignment.center;

                foreach (var question in ticket)
                {
                    doc.InsertParagraph(question.Key.Topic, false, titleInfo);
                    doc.InsertParagraph(question.Key.Question, false, titleQuestion);
                    doc.InsertParagraph(question.Key.Info, false, titleInfo);
                    foreach (var answer in question.Value)
                    {
                        doc.InsertParagraph(answer.Text, false, contenttext);
                    }
                }
                doc.InsertParagraph("");

                Paragraph p = doc.InsertParagraph("Підпис працівника який проходить тестування ___________________________________", false, contenttext);
                p.Alignment = Alignment.left;

                doc.InsertParagraph("");
                doc.InsertParagraph(@"Підпис членів комісії  ________________________________________________________
                                       ________________________________________________________
                                       ________________________________________________________", false, contenttext).Alignment = Alignment.left;
                doc.Save();

                return(true);
            }
            catch (Exception ex)
            {
                throw new Exception("WriteTicketToWord " + ex.Message);
            }
        }
Beispiel #60
0
        public Battle(List <Property> properties, World world)
            : base(properties, world)
        {
            Initialize();

            var attackerSquadRace             = new List <string>();
            var attackerSquadEntityPopulation = new List <int>();
            var attackerSquadNumbers          = new List <int>();
            var attackerSquadDeaths           = new List <int>();
            var attackerSquadSite             = new List <int>();
            var defenderSquadRace             = new List <string>();
            var defenderSquadEntityPopulation = new List <int>();
            var defenderSquadNumbers          = new List <int>();
            var defenderSquadDeaths           = new List <int>();
            var defenderSquadSite             = new List <int>();

            foreach (Property property in properties)
            {
                switch (property.Name)
                {
                case "outcome":
                    switch (property.Value)
                    {
                    case "attacker won": Outcome = BattleOutcome.AttackerWon; break;

                    case "defender won": Outcome = BattleOutcome.DefenderWon; break;

                    default: Outcome = BattleOutcome.Unknown; world.ParsingErrors.Report("Unknown Battle Outcome: " + property.Value); break;
                    }
                    break;

                case "name": Name = Formatting.InitCaps(property.Value); break;

                case "coords": Coordinates = Formatting.ConvertToLocation(property.Value); break;

                case "war_eventcol": ParentCollection = world.GetEventCollection(Convert.ToInt32(property.Value)); break;

                case "subregion_id": Region = world.GetRegion(Convert.ToInt32(property.Value)); break;

                case "feature_layer_id": UndergroundRegion = world.GetUndergroundRegion(Convert.ToInt32(property.Value)); break;

                case "site_id": Site = world.GetSite(Convert.ToInt32(property.Value)); break;

                case "attacking_hfid": NotableAttackers.Add(world.GetHistoricalFigure(Convert.ToInt32(property.Value))); break;

                case "defending_hfid": NotableDefenders.Add(world.GetHistoricalFigure(Convert.ToInt32(property.Value))); break;

                case "attacking_squad_race": attackerSquadRace.Add(Formatting.FormatRace(property.Value)); break;

                case "attacking_squad_entity_pop": attackerSquadEntityPopulation.Add(Convert.ToInt32(property.Value)); break;

                case "attacking_squad_number": attackerSquadNumbers.Add(Convert.ToInt32(property.Value)); break;

                case "attacking_squad_deaths": attackerSquadDeaths.Add(Convert.ToInt32(property.Value)); break;

                case "attacking_squad_site": attackerSquadSite.Add(Convert.ToInt32(property.Value)); break;

                case "defending_squad_race": defenderSquadRace.Add(Formatting.FormatRace(property.Value)); break;

                case "defending_squad_entity_pop": defenderSquadEntityPopulation.Add(Convert.ToInt32(property.Value)); break;

                case "defending_squad_number": defenderSquadNumbers.Add(Convert.ToInt32(property.Value)); break;

                case "defending_squad_deaths": defenderSquadDeaths.Add(Convert.ToInt32(property.Value)); break;

                case "defending_squad_site": defenderSquadSite.Add(Convert.ToInt32(property.Value)); break;

                case "noncom_hfid": NonCombatants.Add(world.GetHistoricalFigure(Convert.ToInt32(property.Value))); break;
                }
            }

            if (Collection.OfType <AttackedSite>().Any())
            {
                Attacker = Collection.OfType <AttackedSite>().First().Attacker;
                Defender = Collection.OfType <AttackedSite>().First().Defender;
            }
            else if (Collection.OfType <FieldBattle>().Any())
            {
                Attacker = Collection.OfType <FieldBattle>().First().Attacker;
                Defender = Collection.OfType <FieldBattle>().First().Defender;
            }

            foreach (HistoricalFigure attacker in NotableAttackers)
            {
                attacker.Battles.Add(this);
            }

            foreach (HistoricalFigure defender in NotableDefenders)
            {
                defender.Battles.Add(this);
            }

            foreach (HistoricalFigure nonCombatant in NonCombatants)
            {
                nonCombatant.Battles.Add(this);
            }

            for (int i = 0; i < attackerSquadRace.Count; i++)
            {
                AttackerSquads.Add(new Squad(attackerSquadRace[i], attackerSquadNumbers[i], attackerSquadDeaths[i], attackerSquadSite[i], attackerSquadEntityPopulation[i]));
            }

            for (int i = 0; i < defenderSquadRace.Count; i++)
            {
                DefenderSquads.Add(new Squad(defenderSquadRace[i], defenderSquadNumbers[i], defenderSquadDeaths[i], defenderSquadSite[i], defenderSquadEntityPopulation[i]));
            }

            var groupedAttackerSquads = from squad in AttackerSquads
                                        group squad by squad.Race into squadRace
                                        select new { Race = squadRace.Key, Count = squadRace.Sum(squad => squad.Numbers), Deaths = squadRace.Sum(squad => squad.Deaths) };

            foreach (var squad in groupedAttackerSquads)
            {
                Attackers.Add(new Squad(squad.Race, squad.Count + NotableAttackers.Count(attacker => attacker.Race == squad.Race), squad.Deaths + Collection.OfType <HfDied>().Count(death => death.HistoricalFigure.Race == squad.Race && NotableAttackers.Contains(death.HistoricalFigure)), -1, -1));
            }

            foreach (var attacker in NotableAttackers.Where(hf => Attackers.Count(squad => squad.Race == hf.Race) == 0).GroupBy(hf => hf.Race).Select(race => new { Race = race.Key, Count = race.Count() }))
            {
                Attackers.Add(new Squad(attacker.Race, attacker.Count, Collection.OfType <HfDied>().Count(death => NotableAttackers.Contains(death.HistoricalFigure) && death.HistoricalFigure.Race == attacker.Race), -1, -1));
            }
            AttackersAsList = new List <string>();
            foreach (Squad squad in Attackers)
            {
                for (int i = 0; i < squad.Numbers; i++)
                {
                    AttackersAsList.Add(squad.Race);
                }
            }

            var groupedDefenderSquads = from squad in DefenderSquads
                                        group squad by squad.Race into squadRace
                                        select new { Race = squadRace.Key, Count = squadRace.Sum(squad => squad.Numbers), Deaths = squadRace.Sum(squad => squad.Deaths) };

            foreach (var squad in groupedDefenderSquads)
            {
                Defenders.Add(new Squad(squad.Race, squad.Count + NotableDefenders.Count(defender => defender.Race == squad.Race), squad.Deaths + Collection.OfType <HfDied>().Count(death => death.HistoricalFigure.Race == squad.Race && NotableDefenders.Contains(death.HistoricalFigure)), -1, -1));
            }

            foreach (var defender in NotableDefenders.Where(hf => Defenders.Count(squad => squad.Race == hf.Race) == 0).GroupBy(hf => hf.Race).Select(race => new { Race = race.Key, Count = race.Count() }))
            {
                Defenders.Add(new Squad(defender.Race, defender.Count, Collection.OfType <HfDied>().Count(death => NotableDefenders.Contains(death.HistoricalFigure) && death.HistoricalFigure.Race == defender.Race), -1, -1));
            }
            DefendersAsList = new List <string>();
            foreach (Squad squad in Defenders)
            {
                for (int i = 0; i < squad.Numbers; i++)
                {
                    DefendersAsList.Add(squad.Race);
                }
            }

            Deaths = new List <string>();
            foreach (Squad squad in Attackers.Concat(Defenders))
            {
                for (int i = 0; i < squad.Deaths; i++)
                {
                    Deaths.Add(squad.Race);
                }
            }

            AttackerDeathCount = Attackers.Sum(attacker => attacker.Deaths);
            DefenderDeathCount = Defenders.Sum(defender => defender.Deaths);

            if (Outcome == BattleOutcome.AttackerWon)
            {
                Victor = Attacker;
            }
            else if (Outcome == BattleOutcome.DefenderWon)
            {
                Victor = Defender;
            }

            if (ParentCollection is War parentWar)
            {
                if (parentWar.Attacker == Attacker)
                {
                    parentWar.AttackerDeathCount += AttackerDeathCount;
                    parentWar.DefenderDeathCount += DefenderDeathCount;
                }
                else
                {
                    parentWar.AttackerDeathCount += DefenderDeathCount;
                    parentWar.DefenderDeathCount += AttackerDeathCount;
                }
                parentWar.DeathCount += attackerSquadDeaths.Sum() + defenderSquadDeaths.Sum() + Collection.OfType <HfDied>().Count();

                if (Attacker == parentWar.Attacker && Victor == Attacker)
                {
                    parentWar.AttackerVictories.Add(this);
                }
                else
                {
                    parentWar.DefenderVictories.Add(this);
                }
            }

            if (Site != null)
            {
                Site.Warfare.Add(this);
            }

            if (Region != null)
            {
                Region.Battles.Add(this);
            }

            if (UndergroundRegion != null)
            {
                UndergroundRegion.Battles.Add(this);
            }

            if (attackerSquadDeaths.Sum() + defenderSquadDeaths.Sum() + Collection.OfType <HfDied>().Count() == 0)
            {
                Notable = false;
            }

            if (attackerSquadNumbers.Sum() + NotableAttackers.Count > (defenderSquadNumbers.Sum() + NotableDefenders.Count) * 10 && //NotableDefenders outnumbered 10 to 1
                Victor == Attacker &&
                AttackerDeathCount < (NotableAttackers.Count + attackerSquadNumbers.Sum()) * 0.1)    //NotableAttackers lossses < 10%
            {
                Notable = false;
            }
        }