public void Can_serialize_and_deserialize_text_email()
        {
            var serializer = new JsonSerializer<EmailMessage>();
            var email = MessageFactory.EmailWithText(1).Single();
            var json = serializer.SerializeToString(email);
            Assert.IsNotNull(json);
            
            Console.WriteLine(json);

            var deserialized = serializer.DeserializeFromString(json);
            Assert.IsNotNull(deserialized);
        }
        static void Main(string[] args)
        {
            var violations = 0;
            const int count = 1000 * 1000;
            var json = new List<string>();
            var serializer = new JsonSerializer<T>();
            for (int i = 0; i < count; i++)
            {
                var t = new T
                {
                    X = Guid.NewGuid(),
                    Y = i % 2 == 0 ? 'C' : 'P',
                };
                json.Add(serializer.SerializeToString(t));
            }

            var tasks = new List<Task>();
            var tasksCount = args.Length > 0 ? int.Parse(args[0]) : 3;
            for (int jj = 0; jj < tasksCount; jj++)
            {
                int j = jj;
                tasks.Add(Task.Run(() => {
                    for (int i = 0; i < count; i++)
                    {
                        string s = json[i];
                        var t = serializer.DeserializeFromString(s);
                        if (t.Y != (i % 2 == 0 ? 'C' : 'P'))
                        {
                            violations++;
                            Console.WriteLine("Constraint violation index {0} thread {1} expected: {2} received: {3} json: {4}",
                                i, j, i % 2 == 0 ? 'C' : 'P', t.Y, s);
                        }
                    }
                }));
            }
            tasks.ForEach(task => task.Wait());

            Console.WriteLine($"There were {violations} viloations, running {tasksCount} Tasks");
        }
        /// <summary>
        /// Starts the FFMPEG.
        /// </summary>
        /// <param name="state">The state.</param>
        /// <param name="outputPath">The output path.</param>
        /// <param name="cancellationTokenSource">The cancellation token source.</param>
        /// <param name="workingDirectory">The working directory.</param>
        /// <returns>Task.</returns>
        protected async Task <TranscodingJob> StartFfMpeg(
            StreamState state,
            string outputPath,
            CancellationTokenSource cancellationTokenSource,
            string workingDirectory = null)
        {
            Directory.CreateDirectory(Path.GetDirectoryName(outputPath));

            await AcquireResources(state, cancellationTokenSource).ConfigureAwait(false);

            if (state.VideoRequest != null && !string.Equals(state.OutputVideoCodec, "copy", StringComparison.OrdinalIgnoreCase))
            {
                var auth = AuthorizationContext.GetAuthorizationInfo(Request);
                if (auth.User != null)
                {
                    if (!auth.User.Policy.EnableVideoPlaybackTranscoding)
                    {
                        ApiEntryPoint.Instance.OnTranscodeFailedToStart(outputPath, TranscodingJobType, state);

                        throw new ArgumentException("User does not have access to video transcoding");
                    }
                }
            }

            var encodingOptions = ApiEntryPoint.Instance.GetEncodingOptions();

            var transcodingId   = Guid.NewGuid().ToString("N");
            var commandLineArgs = GetCommandLineArguments(outputPath, encodingOptions, state, true);

            var process = new Process()
            {
                StartInfo = new ProcessStartInfo()
                {
                    WindowStyle     = ProcessWindowStyle.Hidden,
                    CreateNoWindow  = true,
                    UseShellExecute = false,

                    // Must consume both stdout and stderr or deadlocks may occur
                    //RedirectStandardOutput = true,
                    RedirectStandardError = true,
                    RedirectStandardInput = true,

                    FileName         = MediaEncoder.EncoderPath,
                    Arguments        = commandLineArgs,
                    WorkingDirectory = string.IsNullOrWhiteSpace(workingDirectory) ? null : workingDirectory,

                    ErrorDialog = false
                },
                EnableRaisingEvents = true
            };

            var transcodingJob = ApiEntryPoint.Instance.OnTranscodeBeginning(outputPath,
                                                                             state.Request.PlaySessionId,
                                                                             state.MediaSource.LiveStreamId,
                                                                             transcodingId,
                                                                             TranscodingJobType,
                                                                             process,
                                                                             state.Request.DeviceId,
                                                                             state,
                                                                             cancellationTokenSource);

            var commandLineLogMessage = process.StartInfo.FileName + " " + process.StartInfo.Arguments;

            Logger.LogInformation(commandLineLogMessage);

            var logFilePrefix = "ffmpeg-transcode";

            if (state.VideoRequest != null)
            {
                if (string.Equals(state.OutputVideoCodec, "copy", StringComparison.OrdinalIgnoreCase) &&
                    string.Equals(state.OutputAudioCodec, "copy", StringComparison.OrdinalIgnoreCase))
                {
                    logFilePrefix = "ffmpeg-directstream";
                }
                else if (string.Equals(state.OutputVideoCodec, "copy", StringComparison.OrdinalIgnoreCase))
                {
                    logFilePrefix = "ffmpeg-remux";
                }
            }

            var logFilePath = Path.Combine(ServerConfigurationManager.ApplicationPaths.LogDirectoryPath, logFilePrefix + "-" + Guid.NewGuid() + ".txt");

            Directory.CreateDirectory(Path.GetDirectoryName(logFilePath));

            // FFMpeg writes debug/error info to stderr. This is useful when debugging so let's put it in the log directory.
            state.LogFileStream = FileSystem.GetFileStream(logFilePath, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read, true);

            var commandLineLogMessageBytes = Encoding.UTF8.GetBytes(Request.AbsoluteUri + Environment.NewLine + Environment.NewLine + JsonSerializer.SerializeToString(state.MediaSource) + Environment.NewLine + Environment.NewLine + commandLineLogMessage + Environment.NewLine + Environment.NewLine);
            await state.LogFileStream.WriteAsync(commandLineLogMessageBytes, 0, commandLineLogMessageBytes.Length, cancellationTokenSource.Token).ConfigureAwait(false);

            process.Exited += (sender, args) => OnFfMpegProcessExited(process, transcodingJob, state);

            try
            {
                process.Start();
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, "Error starting ffmpeg");

                ApiEntryPoint.Instance.OnTranscodeFailedToStart(outputPath, TranscodingJobType, state);

                throw;
            }

            // MUST read both stdout and stderr asynchronously or a deadlock may occurr
            //process.BeginOutputReadLine();

            state.TranscodingJob = transcodingJob;

            // Important - don't await the log task or we won't be able to kill ffmpeg when the user stops playback
            new JobLogger(Logger).StartStreamingLog(state, process.StandardError.BaseStream, state.LogFileStream);

            // Wait for the file to exist before proceeeding
            while (!File.Exists(state.WaitForPath ?? outputPath) && !transcodingJob.HasExited)
            {
                await Task.Delay(100, cancellationTokenSource.Token).ConfigureAwait(false);
            }

            if (state.IsInputVideo && transcodingJob.Type == TranscodingJobType.Progressive && !transcodingJob.HasExited)
            {
                await Task.Delay(1000, cancellationTokenSource.Token).ConfigureAwait(false);

                if (state.ReadInputAtNativeFramerate && !transcodingJob.HasExited)
                {
                    await Task.Delay(1500, cancellationTokenSource.Token).ConfigureAwait(false);
                }
            }

            if (!transcodingJob.HasExited)
            {
                StartThrottler(state, transcodingJob);
            }

            return(transcodingJob);
        }
Example #4
0
 private void UpdateBcapinvoice(string serialno)
 {
     try
     {
         BCAPINVOICESUB[] inv     = gridControl1.DataSource as BCAPINVOICESUB[];
         DataTable        dt      = ConvertToDT(inv);
         DataRow[]        result  = dt.Select(string.Format("SERIALNO='{0}'", serialno));
         List <string>    gridstr = new List <string>();
         foreach (DataRow dr in result)
         {
             gridstr.Add(dr["DOCNO"].ToString());
             gridstr.Add(dr["SERIALNO"].ToString());
         }
         //if(serialno=="1202089925")
         //   return;
         WebRequestPostJson(string.Format("http://{0}/multishop/update", nodeA), JsonSerializer.SerializeToString(gridstr.ToArray()));
         loadData();
     }
     catch (Exception ex)
     {
         MessageBox.Show(ex.Message);
     }
 }
 public static string SerializePicture(Picture picture)
 {
     return(JsonSerializer.SerializeToString <Picture>(picture));
 }
 public static string SerializeUser(User user)
 {
     return(JsonSerializer.SerializeToString <User>(user));
 }
Example #7
0
 public void JsonSerializerHonorsIgnoreMemberAttribute()
 {
     DoIgnoreMemberTest(r => JsonSerializer.SerializeToString(r),
                        s => JsonSerializer.DeserializeFromString <RequestWithIgnoredMembers>(s));
 }
Example #8
0
        protected virtual void OnLoggerLoaded(bool isFirstLoad)
        {
            Logger.Info("Application version: {0}", ApplicationVersion);

            if (!isFirstLoad)
            {
                LogEnvironmentInfo(Logger, ApplicationPaths, false);
            }

            // Put the app config in the log for troubleshooting purposes
            Logger.LogMultiline("Application configuration:", LogSeverity.Info, new StringBuilder(JsonSerializer.SerializeToString(ConfigurationManager.CommonConfiguration)));

            if (Plugins != null)
            {
                var pluginBuilder = new StringBuilder();

                foreach (var plugin in Plugins)
                {
                    pluginBuilder.AppendLine(string.Format("{0} {1}", plugin.Name, plugin.Version));
                }

                Logger.LogMultiline("Plugins:", LogSeverity.Info, pluginBuilder);
            }
        }
Example #9
0
        public void JsonNumericSerializesWithUnderlyingType()
        {
            var json = JsonSerializer.SerializeToString(new { Value = JsonNumericEnum.A });

            Assert.AreEqual(@"{""Value"":0}", json);
        }
Example #10
0
        public void Save(string id, T value)
        {
            var json = JsonSerializer.SerializeToString(value);

            redisClient.Hashes[key][id] = json;
        }
Example #11
0
 public string ToJsonString()
 {
     return(JsonSerializer.SerializeToString <User>(this));
 }
Example #12
0
 public void BindMessage(Type messageType, object instance)
 {
     MessageType       = messageType;
     richTextBox1.Text = JsvFormatter.Format(JsonSerializer.SerializeToString(instance));
 }
Example #13
0
 private static string Serialize(IMessage message)
 {
     return(JsonSerializer.SerializeToString(message));
 }
Example #14
0
		protected void CacheCurrentTask()
		{
			if (LocalCachingEnabled)
			{
				var serializer = new JsonSerializer<TaskMessage>();
				File.WriteAllText(Settings.Default.LocalCache, serializer.SerializeToString(CurrentTask));
			}
		}
Example #15
0
        public static long AddList <T>(string listId, T t)
        {
            var value = JsonSerializer.SerializeToString(t);

            return(Cache.ListLeftPush(listId, value));
        }
Example #16
0
 static PersonGenerator()
 {
     _names = File.ReadAllText("names.json").FromJson<Names>();
     var serializer = new JsonSerializer<Person>();
     _emptySize = serializer.SerializeToString(new Person()).Length;
 }
Example #17
0
        public void CanSerializeIntFlag()
        {
            var val = JsonSerializer.SerializeToString(FlagEnum.A);

            Assert.AreEqual("0", val);
        }
Example #18
0
 public static string ToJson <T>(this T obj)
 {
     return(JsConfig.PreferInterfaces
         ? JsonSerializer.SerializeToString(obj, AssemblyUtils.MainInterface <T>())
         : JsonSerializer.SerializeToString(obj));
 }
        protected override void OnArrange()
        {
            base.OnArrange();

            MockLeanKitApi.Setup(x => x.GetBoard(It.IsAny <long>())).Returns(_testBoard);

            var serializer = new JsonSerializer <GitHubIssues.Issue>();

            var issue1 = new GitHubIssues.Issue()
            {
                Id     = 1,
                Number = 1,
                State  = "Open"
            };

            var restResponse1 = new RestResponse()
            {
                Content    = serializer.SerializeToString(issue1),
                StatusCode = HttpStatusCode.OK
            };

            MockRestClient.Setup(
                x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/1") && y.Method == Method.GET)))
            .Returns(restResponse1);
            MockRestClient.Setup(
                x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/1") && y.Method == Method.PATCH)))
            .Returns(restResponse1);

            var issue2 = new GitHubIssues.Issue()
            {
                Id     = 2,
                Number = 2,
                State  = "Closed"
            };

            var restResponse2 = new RestResponse()
            {
                Content    = serializer.SerializeToString(issue2),
                StatusCode = HttpStatusCode.OK
            };

            MockRestClient.Setup(
                x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/2") && y.Method == Method.GET)))
            .Returns(restResponse2);
            MockRestClient.Setup(
                x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/2") && y.Method == Method.PATCH)))
            .Returns(restResponse2);

            var errorSerializer = new JsonSerializer <GitHubIssues.ErrorMessage>();
            var errorResponse   = new RestResponse()
            {
                Content = errorSerializer.SerializeToString(new GitHubIssues.ErrorMessage()
                {
                    Message = "Error"
                }),
                StatusCode = HttpStatusCode.NotFound
            };

            MockRestClient.Setup(
                x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/3") && y.Method == Method.GET)))
            .Returns(errorResponse);
            MockRestClient.Setup(
                x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/3") && y.Method == Method.PATCH)))
            .Returns(errorResponse);
        }
Example #20
0
 public void JsonSerializerReturnsTimeSpanAsString()
 {
     Assert.AreEqual("\"PT0S\"", JsonSerializer.SerializeToString(new TimeSpan()));
     Assert.AreEqual("\"PT0.0000001S\"", JsonSerializer.SerializeToString(new TimeSpan(1)));
 }
        /// <summary>
        /// 存储数据到hash表
        /// </summary>
        public bool Set <T>(string hashId, string key, T t)
        {
            var value = JsonSerializer.SerializeToString <T>(t);

            return(Redis.SetEntryInHash(hashId, key, value));
        }
 public static string SerializePlace(Place place)
 {
     return(JsonSerializer.SerializeToString <Place>(place));
 }
Example #23
0
        protected override void OnArrange()
        {
            base.OnArrange();

            MockLeanKitApi.Setup(x => x.GetBoard(It.IsAny <long>())).Returns(_testBoard);

            var serializer = new JsonSerializer <GitHubIssues.Issue>();

            var issue1 = new GitHubIssues.Issue()
            {
                Id     = 1,
                Number = 1,
                Title  = "Issue 1",
                Body   = "Issue 1",
                State  = "Open"
            };

            var restResponse1 = new RestResponse()
            {
                Content = serializer.SerializeToString(issue1), StatusCode = HttpStatusCode.OK
            };

            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/1") && y.Method == Method.GET))).Returns(restResponse1);
            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/1") && y.Method == Method.PATCH))).Returns(restResponse1);

            var issue2 = new GitHubIssues.Issue()
            {
                Id     = 2,
                Number = 2,
                Title  = "Issue 2",
                Body   = "Issue 2",
                State  = "Open"
            };

            var restResponse2 = new RestResponse()
            {
                Content = serializer.SerializeToString(issue2), StatusCode = HttpStatusCode.OK
            };

            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/2") && y.Method == Method.GET))).Returns(restResponse2);
            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/2") && y.Method == Method.PATCH))).Returns(restResponse2);

            var issue3 = new GitHubIssues.Issue()
            {
                Id     = 3,
                Number = 3,
                Title  = "Issue 3",
                Body   = "Issue 3",
                State  = "Open"
            };

            var restResponse3 = new RestResponse()
            {
                Content = serializer.SerializeToString(issue3), StatusCode = HttpStatusCode.OK
            };

            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/3") && y.Method == Method.GET))).Returns(restResponse3);
            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/3") && y.Method == Method.PATCH))).Returns(restResponse3);

            var issue4 = new GitHubIssues.Issue()
            {
                Id     = 4,
                Number = 4,
                Title  = "Issue 4",
                Body   = "Issue 4",
                State  = "Open"
            };

            var restResponse4 = new RestResponse()
            {
                Content = serializer.SerializeToString(issue4), StatusCode = HttpStatusCode.OK
            };

            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/4") && y.Method == Method.GET))).Returns(restResponse4);
            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("issues/4") && y.Method == Method.PATCH))).Returns(restResponse4);
        }
 public static string SerializeRating(Post rating)
 {
     return(JsonSerializer.SerializeToString <Post>(rating));
 }
Example #25
0
        protected override void OnArrange()
        {
            base.OnArrange();

            MockLeanKitApi.Setup(x => x.GetBoard(It.IsAny <long>())).Returns(_testBoard);

            var serializer = new JsonSerializer <List <GitHubIssues.Issue> >();

            var issue1 = new GitHubIssues.Issue()
            {
                Id     = 1,
                Number = 1,
                State  = "Open",
                Body   = "New Issue 1",
                Title  = "New Issue 1"
            };

            var issue2 = new GitHubIssues.Issue()
            {
                Id     = 2,
                Number = 2,
                State  = "Open",
                Body   = "New Issue 2",
                Title  = "New Issue 2"
            };

            var issue3 = new GitHubIssues.Issue()
            {
                Id     = 3,
                Number = 3,
                State  = "Open",
                Body   = "New Issue 3",
                Title  = "New Issue 3"
            };

            var restResponse1 = new RestResponse()
            {
                Content = serializer.SerializeToString(new List <GitHubIssues.Issue>()
                {
                    issue1
                }),
                StatusCode = HttpStatusCode.OK
            };

            var noRestResponse = new RestResponse()
            {
                StatusCode = HttpStatusCode.OK, Content = ""
            };

            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/1/issues") && y.Method == Method.GET && y.Parameters[0].Value.ToString() == "Open"))).Returns(restResponse1);
            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/1/issues") && y.Method == Method.GET && y.Parameters[0].Value.ToString() != "Open"))).Returns(noRestResponse);
            MockLeanKitApi.Setup(x => x.GetCardByExternalId(1, It.IsAny <string>())).Returns((Card)null);
            MockLeanKitApi.Setup(x => x.AddCard(1, It.IsAny <Card>(), It.IsAny <string>())).Returns(_testCardAddResult1);

            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/2/issues") && y.Method == Method.GET && y.Parameters[0].Value.ToString() == "Open"))).Returns(restResponse1);
            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/2/issues") && y.Method == Method.GET && y.Parameters[0].Value.ToString() != "Open"))).Returns(noRestResponse);
            MockLeanKitApi.Setup(x => x.GetCardByExternalId(2, It.IsAny <string>())).Returns((Card)null);
            MockLeanKitApi.Setup(x => x.AddCard(2, It.IsAny <Card>(), It.IsAny <string>())).Returns(_testCardAddResult1);

            var restResponse3 = new RestResponse()
            {
                Content = serializer.SerializeToString(new List <GitHubIssues.Issue>()
                {
                    issue1, issue2, issue3
                }),
                StatusCode = HttpStatusCode.OK
            };

            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/3/issues") && y.Method == Method.GET && y.Parameters[0].Value.ToString() == "Open"))).Returns(restResponse3);
            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/3/issues") && y.Method == Method.GET && y.Parameters[0].Value.ToString() != "Open"))).Returns(noRestResponse);
            MockLeanKitApi.Setup(x => x.GetCardByExternalId(3, It.IsAny <string>())).Returns((Card)null);
            MockLeanKitApi.Setup(x => x.AddCard(3, It.IsAny <Card>(), It.IsAny <string>())).Returns(_testCardAddResult1);

            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/4/issues") && y.Method == Method.GET && y.Parameters[0].Value.ToString() == "Open"))).Returns(restResponse1);
            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/4/issues") && y.Method == Method.GET && y.Parameters[0].Value.ToString() != "Open"))).Returns(noRestResponse);
            MockLeanKitApi.Setup(x => x.GetCardByExternalId(4, It.IsAny <string>())).Returns(new Card()
            {
                Id = 4, ExternalSystemName = "GitHub"
            });
            MockLeanKitApi.Setup(x => x.AddCard(4, It.IsAny <Card>(), It.IsAny <string>())).Returns(_testCardAddResult1);

            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/5/issues") && y.Method == Method.GET && y.Parameters[0].Value.ToString() == "Open"))).Returns(restResponse1);
            MockRestClient.Setup(x => x.Execute(It.Is <RestRequest>(y => y.Resource.Contains("/5/issues") && y.Method == Method.GET && y.Parameters[0].Value.ToString() != "Open"))).Returns(noRestResponse);
            MockLeanKitApi.Setup(x => x.GetCardByExternalId(5, It.IsAny <string>())).Returns(new Card()
            {
                Id = 4, ExternalSystemName = "GitHubby"
            });
            MockLeanKitApi.Setup(x => x.AddCard(5, It.IsAny <Card>(), It.IsAny <string>())).Returns(_testCardAddResult1);
        }
 public static string SerializeComment(CommentOnPost comment)
 {
     return(JsonSerializer.SerializeToString <CommentOnPost>(comment));
 }
        public override async Task ProcessRequestAsync(IRequest httpReq, IResponse httpRes, string operationName)
        {
            if (HostContext.ApplyCustomHandlerRequestFilters(httpReq, httpRes))
            {
                return;
            }

            var response = this.RequestInfo ?? GetRequestInfo(httpReq);

            response.HandlerFactoryArgs = HttpHandlerFactory.DebugLastHandlerArgs;
            response.DebugString        = "";
#if NET45
            if (HttpContext.Current != null)
            {
                response.DebugString += HttpContext.Current.Request.GetType().FullName
                                        + "|" + HttpContext.Current.Response.GetType().FullName;
            }

            if (HostContext.IsAspNetHost)
            {
                var aspReq = (HttpRequestBase)httpReq.OriginalRequest;
                response.GetLeftPath                = aspReq.Url.GetLeftAuthority();
                response.Path                       = aspReq.Path;
                response.UserHostAddress            = aspReq.UserHostAddress;
                response.ApplicationPath            = aspReq.ApplicationPath;
                response.ApplicationVirtualPath     = System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath;
                response.VirtualAbsolutePathRoot    = VirtualPathUtility.ToAbsolute("/");
                response.VirtualAppRelativePathRoot = VirtualPathUtility.ToAppRelative("/");

                if (!Env.IsMono)
                {
                    var userIdentity = aspReq.LogonUserIdentity;
                    if (userIdentity != null)
                    {
                        response.LogonUserInfo = new Dictionary <string, string> {
                            { "Name", userIdentity.Name },
                            { "AuthenticationType", userIdentity.AuthenticationType },
                            { "IsAuthenticated", userIdentity.IsAuthenticated.ToString() },
                            { "IsAnonymous", userIdentity.IsAnonymous.ToString() },
                            { "IsGuest", userIdentity.IsGuest.ToString() },
                            { "IsSystem", userIdentity.IsSystem.ToString() },
                            { "Groups", userIdentity.Groups.Map(x => x.Value).Join(", ") },
                        };
                        var winUser = userIdentity.User;
                        if (winUser != null)
                        {
                            response.LogonUserInfo["User"] = winUser.Value;
                            response.LogonUserInfo["User.AccountDomainSid"] = winUser.AccountDomainSid?.ToString() ?? "null";
                            response.LogonUserInfo["User.IsAccountSid"]     = winUser.IsAccountSid().ToString();
                        }
                    }
                }
            }
#endif

            var json = JsonSerializer.SerializeToString(response);
            httpRes.ContentType = MimeTypes.Json;
            try
            {
                await httpRes.WriteAsync(json).ConfigAwait();
            }
            finally
            {
                httpRes.EndHttpHandlerRequest(skipHeaders: true);
            }
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="ImageGalleryModel"/> class.
 /// </summary>
 public ImageGalleryModel() : base()
 {
     this.SerializedThumbnailSizeModel = JsonSerializer.SerializeToString(this.DefaultThumbnailSize());
 }
Example #29
0
 public override string ToString()
 {
     return(JsonSerializer.SerializeToString(_hash));
 }
Example #30
0
 public static byte[] SerializeToUtf8Bytes <T>(T value)
 {
     return(Encoding.UTF8.GetBytes(JsonSerializer.SerializeToString(value)));
 }
 public string Serialize <T>(T obj)
 {
     return(JsonSerializer.SerializeToString <T>(obj));
 }
        public static string Serialize(dynamic instance)
        {
            var json = JsonSerializer.SerializeToString(instance);

            return(json);
        }
Example #33
0
 /// <summary>
 /// Saves the settings file.
 /// </summary>
 private void UpdateSettings()
 {
     settings.AvailableMods = AvailableMods.ToList();
     settings.InstalledMods = InstalledMods.ToList();
     File.WriteAllText(Settings.SettingsPath, JsonSerializer.SerializeToString(settings));
 }
Example #34
0
 public void test_rect_different_cultures(string culture)
 {
     var currentCulture = CultureInfo.GetCultureInfo(culture);
     Thread.CurrentThread.CurrentCulture = currentCulture;
     Thread.CurrentThread.CurrentUICulture = currentCulture;
     var s = new JsonSerializer<Rect>();
     var r = new Rect(23, 34, 1024, 768);
     var interim = s.SerializeToString(r);
     var r2 = s.DeserializeFromString(interim);
     Assert.AreEqual(r, r2);
 }
Example #35
0
        private void Getitem(object handler, EventArgs e)
        {
            bool   input         = (((Button)handler).Name[0].ToString(CultureInfo.InvariantCulture) == "1");
            string servercommand = ((Button)handler).Name.Substring(1);

            if (input)
            {
                if (servercommand != "DEVCOLOR")
                {
                    var form = new InputFrm("Input", m_descriptions[servercommand], "Confirm", "Cancel");
                    if (servercommand != "DEVCREATETEAM" && servercommand != "DEVMSG")
                    {
                        form.InputBox.KeyDown += Suppress_Space;
                    }

                    if (servercommand == "DEVCREATETEAM")
                    {
                        form.InputBox.MaxLength = 20;
                    }
                    else if (servercommand == "DEVMSG")
                    {
                        form.InputBox.MaxLength = 250;
                    }
                    else
                    {
                        form.InputBox.MaxLength = 14;
                    }

                    if (form.ShowDialog() == DialogResult.OK)
                    {
                        if (form.InputBox.Text == "")
                        {
                            MessageBox.Show("Input cannot be empty");
                            return;
                        }
                        Program.ChatServer.SendPacket(DevServerPackets.DevPointCommand,
                                                      JsonSerializer.SerializeToString(
                                                          new PacketCommand
                        {
                            Command = servercommand,
                            Data    = form.InputBox.Text.Trim()
                        }));
                    }
                }
                else
                {
                    var selectcolor = new ColorDialog();
                    if (selectcolor.ShowDialog() == DialogResult.OK)
                    {
                        Program.ChatServer.SendPacket(DevServerPackets.DevPointCommand,
                                                      JsonSerializer.SerializeToString(
                                                          new PacketCommand
                        {
                            Command = servercommand,
                            Data    = selectcolor.Color.R + "," + selectcolor.Color.G + "," + selectcolor.Color.B
                        }));
                    }
                }
            }
            else
            {
                if (MessageBox.Show("Confirm", "Are you sure?", MessageBoxButtons.YesNo) == DialogResult.Yes)
                {
                    Program.ChatServer.SendPacket(DevServerPackets.DevPointCommand,
                                                  JsonSerializer.SerializeToString(
                                                      new PacketCommand
                    {
                        Command = servercommand
                    }));
                }
            }
        }