Ejemplo n.º 1
0
        public async Task <bool> Handle(EnviarAtualizacaoCadastralProdamCommand request, CancellationToken cancellationToken)
        {
            var httpClient = httpClientFactory.CreateClient("servicoAtualizacaoCadastralProdam");

            var body     = JsonConvert.SerializeObject(request.ResponsavelDto, UtilJson.ObterConfigConverterNulosEmVazio());
            var resposta = await httpClient.PostAsync($"AtualizarResponsavelAluno", new StringContent(body, Encoding.UTF8, "application/json"));

            Console.WriteLine(body);
            if (resposta.IsSuccessStatusCode && resposta.StatusCode != HttpStatusCode.NoContent)
            {
                var json = await resposta.Content.ReadAsStringAsync();

                Console.WriteLine(body);
                Console.WriteLine(json);
                SentrySdk.CaptureMessage(json);

                if (json.ToLower().Contains("false"))
                {
                    throw new Exception($"Não foi possível atualizar os dados cadastrais do cpf {request.ResponsavelDto.CPF}. Retorno: {json}");
                }

                return(true);
            }
            else
            {
                throw new Exception($"Não foi possível atualizar os dados cadastrais do cpf {request.ResponsavelDto.CPF}.");
            }
        }
Ejemplo n.º 2
0
        private static bool ProcessHeader(string stringType, string key, IDictionary <string, string> dic,
                                          Template template)
        {
            if (stringType != "G")
            {
                return(false);
            }

            var json = dic[key];
            var el   = UtilJson.Deserialize <TemplateInfo>(json);

            // Template header config

            // DotLiquid specific config
            if (el.DotLiquidFilterTypes != null && el.DotLiquidFilterTypes.Count > 0)
            {
                var assemblyPaths = el.DotLiquidFilterAssemblies;
                var typeList      = new List <Type>();
                foreach (var typeDef in el.DotLiquidFilterTypes)
                {
                    var type = GetType(assemblyPaths, typeDef);
                    typeList.Add(type);
                }

                template.ExtendedInfo.Add("DotLiquidFilterTypes", typeList);
            }

            return(true);
        }
        public async Task <bool> Handle(GerarRelatorioAssincronoCommand request, CancellationToken cancellationToken)
        {
            try
            {
                ParametrosRelatorioDto parametrosDoDto = ObterParametrosRelatorio(request.Dados);

                var post = new ExecucaoRelatorioRequisicaoDto()
                {
                    UnidadeRelatorioUri = request.CaminhoRelatorio,
                    Async            = false,
                    SalvarSnapshot   = false,
                    FormatoSaida     = request.Formato.Name(),
                    Interativo       = false,
                    IgnorarPaginacao = false,
                    Paginas          = null,
                    Parametros       = parametrosDoDto
                };


                SentrySdk.CaptureMessage("6.1 - Obtendo jSessionId...");

                var jsessionId = await loginService.ObterTokenAutenticacao(configuration.GetSection("ConfiguracaoJasper:Username").Value, configuration.GetSection("ConfiguracaoJasper:Password").Value);

                SentrySdk.CaptureMessage($"6.2 - jSessionId = {jsessionId}");


                SentrySdk.CaptureMessage("6.3 - Solicitando relatório...");


                var retorno = await execucaoRelatorioService.SolicitarRelatorio(post, jsessionId);

                var exportacaoId = retorno?.Exports?.FirstOrDefault()?.Id;

                SentrySdk.CaptureMessage($"6.4 - Exportação Id = {exportacaoId}");

                if (exportacaoId != null)
                {
                    var dadosRelatorio = new DadosRelatorioDto(retorno.RequestId, exportacaoId.Value, request.CodigoCorrelacao, jsessionId);
                    var publicacaoFila = new PublicaFilaDto(dadosRelatorio, RotasRabbit.RotaRelatoriosProcessando, null, request.CodigoCorrelacao);

                    servicoFila.PublicaFila(publicacaoFila);

                    var jsonPublicaFila = UtilJson.ConverterApenasCamposNaoNulos(publicacaoFila);
                    Console.WriteLine(jsonPublicaFila);

                    SentrySdk.CaptureMessage("6.5 - Sucesso na publicação da fila: " + publicacaoFila.Rota);
                    return(true);
                }

                SentrySdk.CaptureMessage("6.6 - Erro na geração");

                return(false);
            }
            catch (Exception ex)
            {
                SentrySdk.CaptureException(ex);
                throw ex;
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Serialize session state.
        /// </summary>
        public static void Serialize(AppJson appJson, out string jsonClient)
        {
            appJson.RequestJson = null;

            UtilStopwatch.TimeStart("Serialize");
            UtilJson.Serialize(appJson, out string jsonSession, out jsonClient);
            UtilStopwatch.TimeStop("Serialize");
            UtilServer.Session.SetString("AppInternal", jsonSession);

            UtilStopwatch.Log(string.Format("JsonSession.Length={0:n0}; JsonClient.Length={1:n0};", jsonSession.Length, jsonClient.Length));
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Deserialize session state.
        /// </summary>
        public static AppJson Deserialize()
        {
            AppJson result = null;
            string  json   = UtilServer.Session.GetString("AppInternal");

            if (!string.IsNullOrEmpty(json)) // Not session expired.
            {
                UtilStopwatch.TimeStart("Deserialize");
                result = (AppJson)UtilJson.Deserialize(json);
                UtilStopwatch.TimeStop("Deserialize");
            }
            return(result);
        }
        public async Task Executar(FiltroRelatorioDto request)
        {
            var relatorioQuery = request.ObterObjetoFiltro <ObterRelatorioBoletimEscolarQuery>();
            var relatorio      = await mediator.Send(relatorioQuery);

            var jsonString = JsonConvert.SerializeObject(relatorio, UtilJson.ObterConfigConverterNulosEmVazio());

            if (relatorioQuery.Modalidade == Modalidade.EJA)
            {
                await mediator.Send(new GerarRelatorioAssincronoCommand("/sgp/RelatorioBoletimEscolarEja/BoletimEscolarEja", jsonString, TipoFormatoRelatorio.Pdf, request.CodigoCorrelacao));
            }
            else
            {
                await mediator.Send(new GerarRelatorioAssincronoCommand("/sgp/RelatorioBoletimEscolar/BoletimEscolar", jsonString, TipoFormatoRelatorio.Pdf, request.CodigoCorrelacao));
            }
        }
Ejemplo n.º 7
0
        private static SourceContext GetSourceContext(Definition definition)
        {
            var result = new SourceContext();

            if (definition.ModelSourceType == SourceType.Object)
            {
                Type modelType;
                Type modelInitializerType = null;
                if (!string.IsNullOrEmpty(definition.ModelTypeAssemblyPath))
                {
                    var myAssembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(definition.ModelTypeAssemblyPath);
                    modelType = myAssembly.GetType(definition.ModelType);
                    if (!string.IsNullOrEmpty(definition.ModelInitializerType))
                    {
                        modelInitializerType = myAssembly.GetType(definition.ModelInitializerType);
                    }
                }
                else
                {
                    modelType = Type.GetType(definition.ModelType);
                    if (!string.IsNullOrEmpty(definition.ModelInitializerType))
                    {
                        modelInitializerType = Type.GetType(definition.ModelInitializerType);
                    }
                }

                if (modelType == null)
                {
                    throw new ModelException(ModelException.FailValue.CouldNotLoadTypeForModel);
                }

                var json        = File.ReadAllText(definition.Model);
                var jsonOptions = UtilJson.GetDefaultOptions();
                var rawSource   = JsonSerializer.Deserialize(json, modelType, jsonOptions);
                if (modelInitializerType != null)
                {
                    var initializer = (IInitializer)Activator.CreateInstance(modelInitializerType);
                    initializer.Initialize(rawSource);
                }

                var source = new ObjectSource(rawSource);
                result.Source = source;
                result.Type   = modelType;
            }

            return(result);
        }
Ejemplo n.º 8
0
        public override void Execute(IDictionary <string, object> input)
        {
            var macroName   = input.Get <string>(NAME);
            var macroFolder = input.Get <string>(FOLDER);

            if (!string.IsNullOrEmpty(macroFolder) && !Directory.Exists(macroFolder))
            {
                Directory.CreateDirectory(macroFolder);
            }

            var macroHolder = Context.MacroHolder;

            CleanMacroHolder();
            var json      = UtilJson.Serialize(macroHolder);
            var macroPath = Path.Combine(macroFolder, macroName + ".macro.json");

            File.WriteAllText(macroPath, json);
            _collectionProvider.AddConfigValue(CollectionValues.Macro, macroName, macroPath);

            Context.MacroHolder = null;
        }
Ejemplo n.º 9
0
        public static Definition LoadFrom(string sourceFile)
        {
            if (!File.Exists(sourceFile))
            {
                throw new TemplateException(TemplateException.FailValue.DefinitionFileNotFound);
            }

            var json       = File.ReadAllText(sourceFile);
            var definition = UtilJson.Deserialize <Definition>(json);

            var definitionDir = Path.GetDirectoryName(sourceFile);

            definition.Template     = UtilFile.ToAbsoluteFrom(definitionDir, definition.Template);
            definition.Model        = UtilFile.ToAbsoluteFrom(definitionDir, definition.Model);
            definition.OutputTarget = UtilFile.ToAbsoluteFrom(definitionDir, definition.OutputTarget);

            if (!string.IsNullOrEmpty(definition.ModelTypeAssemblyPath))
            {
                definition.ModelTypeAssemblyPath =
                    UtilFile.ToAbsoluteFrom(definitionDir, definition.ModelTypeAssemblyPath);
            }

            return(definition);
        }
Ejemplo n.º 10
0
        private static void RunComponentJson()
        {
            // Reference to self
            {
                MyComponent source = new MyComponent(null);
                source.Component = source;
                UtilJson.Serialize(source, out string json, out string jsonClient);
                MyComponent dest = (MyComponent)UtilJson.Deserialize(json);
                UtilFramework.Assert(dest.Component == dest);
            }
            // ComponentJson reference to ComponentJson do not send to client
            {
                MyComponent source = new MyComponent(null);
                source.HtmlAbc = new Html(source)
                {
                    TextHtml = "JK"
                };
                source.MyTextSession = "SessionValueX";
                source.MyTextClient  = "ClientValueX";
                source.MyIgnore      = "IgnoreX";
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                MyComponent dest = (MyComponent)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(!jsonClient.Contains("HtmlAbc")); // Do not send property name of ComponentJson reference to client

                UtilFramework.Assert(jsonSession.Contains("SessionValueX"));
                UtilFramework.Assert(!jsonClient.Contains("SessionValueX"));

                UtilFramework.Assert(!jsonSession.Contains("ClientValueX"));
                UtilFramework.Assert(jsonClient.Contains("ClientValueX"));

                UtilFramework.Assert(!jsonSession.Contains("IgnoreX"));
                UtilFramework.Assert(!jsonClient.Contains("IgnoreX"));

                UtilFramework.Assert(!jsonSession.Contains("Owner"));
                UtilFramework.Assert(!jsonClient.Contains("Owner"));
            }
            // ComponentJson.IsHide
            {
                MyComponent source = new MyComponent(null);
                new Html(source)
                {
                    TextHtml = "X11"
                };
                new Html(source)
                {
                    TextHtml = "X12", IsHide = true
                };
                new Html(source)
                {
                    TextHtml = "X13"
                };
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                MyComponent dest = (MyComponent)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(dest.List.Count == 3);
                UtilFramework.Assert(jsonClient.Contains("X11"));
                UtilFramework.Assert(!jsonClient.Contains("X12"));
                UtilFramework.Assert(jsonClient.Contains("X13"));
            }
            // ComponentJson.IsHide (Dto to ComponentJson
            {
                My source = new My();
                source.MyComponent = new MyComponent(null)
                {
                    Id = 789, IsHide = true
                };
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                My dest = (My)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(!jsonClient.Contains("789"));
            }
            // ComponentJson.IsHide
            {
                MyComponent source = new MyComponent(null);
                source.Html = new Html(source)
                {
                    TextHtml = "My123", IsHide = true
                };
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                MyComponent dest = (MyComponent)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(jsonSession.Contains("My123"));
                UtilFramework.Assert(!jsonClient.Contains("My123"));
            }
            // ComponentJson.IsHide (Root)
            {
                MyComponent source = new MyComponent(null);
                source.IsHide = true;
                source.Html   = new Html(source)
                {
                    TextHtml = "My123", IsHide = true
                };
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                MyComponent dest = (MyComponent)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(jsonSession.Contains("My123"));
                UtilFramework.Assert(jsonClient == "");
            }
            // Reference to Row
            {
                MyComponent source = new MyComponent(null);
                source.MyRow = new MyRow {
                    Text = "My123", DateTime = DateTime.Now
                };
                source.MyRowList = new List <Row>();
                source.MyRowList.Add(new MyRow {
                    Text = "My1234", DateTime = DateTime.Now
                });
                source.MyRowList.Add(new MyRow {
                    Text = "My12356", DateTime = DateTime.Now
                });
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                MyComponent dest = (MyComponent)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(!jsonClient.Contains("My123"));
            }
            // Reference to Row
            {
                MyComponent source = new MyComponent(null);
                source.MyRowList = new List <Row>();
                source.MyRowList.Add(new MyRow {
                    Text = "My1234", DateTime = DateTime.Now
                });
                source.MyRowList.Add(new MyRow {
                    Text = "My12356", DateTime = DateTime.Now
                });
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                MyComponent dest = (MyComponent)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(!jsonClient.Contains("My123"));
            }
            // Field of object type with Row value
            {
                MyComponent source = new MyComponent(null);
                source.V = new MyRow()
                {
                    Text = "Hello"
                };
                try
                {
                    UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                }
                catch (Exception exception)
                {
                    UtilFramework.Assert(exception.Message == "Can not send data row to client!"); // V is object declaration therefore no Row detection.
                }
            }
            // Reference to removed ComponentJson
            {
                MyComponent source = new MyComponent(null);
                var         html   = new Html(source)
                {
                    TextHtml = "My"
                };
                source.Html = html;
                html.ComponentRemove();
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                MyComponent dest = (MyComponent)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(dest.Html == null);
            }
            // ComponentJson reference in list
            {
                MyComponent source = new MyComponent(null);
                var         html   = new Html(source)
                {
                    TextHtml = "My"
                };
                source.HtmlList = new List <Html>();
                source.HtmlList.Add(html);
                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                try
                {
                    var dest = (MyComponent)UtilJson.Deserialize(jsonSession);
                }
                catch (Exception exception)
                {
                    UtilFramework.Assert(exception.Message == "Reference to ComponentJson in List not supported!");
                }
            }
            {
                MyComponent source = new MyComponent(null);
                new MyComponent(source);
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                var dest = (MyComponent)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(dest.List.Count == 1);
            }
            {
                MyComponent source = new MyComponent(null);
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                var dest = (MyComponent)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(dest.Index == null);
            }
            {
                MyComponent source = new MyComponent(null);
                source.Index = 0;
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                var dest = (MyComponent)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(dest.Index == 0);
            }
            {
                MyComponent source = new MyComponent(null);
                source.Index = -1;
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                var dest = (MyComponent)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(dest.Index == -1);
            }
            {
                My   source       = new My();
                var  myComponent1 = new MyComponent(null);
                Html html1        = new Html(myComponent1)
                {
                    TextHtml = "A"
                };
                myComponent1.Dto = new Dto {
                    Css = "A", Html = html1
                };
                var  myComponent2 = new MyComponent(null);
                Html html2        = new Html(myComponent2)
                {
                    TextHtml = "B"
                };
                myComponent2.Dto = new Dto {
                    Css = "B", Html = html2
                };
                source.List.Add(myComponent1);

                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                var dest = (My)UtilJson.Deserialize(jsonSession);
                dest.List[0].Dto.Html.TextHtml = "abc";
                UtilFramework.Assert(((Html)dest.List[0].List[0]).TextHtml == "abc");

                source.List.Add(myComponent2);
                try
                {
                    UtilJson.Serialize(source, out jsonSession, out jsonClient);
                }
                catch (Exception exception)
                {
                    UtilFramework.Assert(exception.Message == "JsonClient can only have one ComponentJson graph!");
                }
            }
            {
                My   source       = new My();
                var  myComponent1 = new MyComponent(null);
                Html html1        = new Html(myComponent1)
                {
                    TextHtml = "A"
                };
                myComponent1.Dto = new Dto {
                    Css = "A", Html = html1
                };
                var  myComponent2 = new MyComponent(null);
                Html html2        = new Html(myComponent2)
                {
                    TextHtml = "B"
                };
                myComponent2.Dto = new Dto {
                    Css = "B", Html = html2
                };
                var myComponent3 = new MyComponent(myComponent1);
                source.List.Add(myComponent3); // Reference not to root!
                try
                {
                    UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                }
                catch (Exception exception)
                {
                    UtilFramework.Assert(exception.Message == "Referenced ComponentJson not root!");
                }
                source.List.Remove(myComponent3);
                source.List.Add(myComponent1);
                source.List.Add(myComponent2);
                try
                {
                    UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                }
                catch (Exception exception)
                {
                    UtilFramework.Assert(exception.Message == "JsonClient can only have one ComponentJson graph!");
                }
            }
            {
                My   source       = new My();
                var  myComponent1 = new MyComponent(null);
                Html html1        = new Html(myComponent1)
                {
                    TextHtml = "A"
                };
                myComponent1.Dto = new Dto {
                    Css = "A", Html = html1
                };
                var  myComponent2 = new MyComponent(null);
                Html html2        = new Html(myComponent2)
                {
                    TextHtml = "B"
                };
                myComponent2.Dto = new Dto {
                    Css = "B", Html = html1
                };                                                      // Reference to object in different graph
                source.List.Add(myComponent2);
                source.List.Add(myComponent1);
                try
                {
                    UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                }
                catch (Exception exception)
                {
                    UtilFramework.Assert(exception.Message == "Referenced ComponentJson not in same object graph!");
                }
            }
            {
                var source = new MyComponent(null);

                source.Html = new Html(source)
                {
                    TextHtml = "Hello"
                };

                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);

                UtilFramework.Assert(!jsonSession.Contains("Owner"));

                var dest = (MyComponent)UtilJson.Deserialize(jsonSession);

                var htmlOne = dest.Html;
                var htmlTwo = dest.List.OfType <Html>().First();

                htmlOne.TextHtml = "K";
                UtilFramework.Assert(htmlOne.TextHtml == htmlTwo.TextHtml);
            }
            // Referenced ComponentJson not in same graph
            {
                var source = new MyComponent(null);
                source.Html = new Html(null);

                try
                {
                    UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                }
                catch (Exception exception)
                {
                    UtilFramework.Assert(exception.Message == "Referenced ComponentJson not in same object graph!");
                }
            }
        }
Ejemplo n.º 11
0
        public static void Run()
        {
            {
                UtilFramework.CamelCase camelCase = new UtilFramework.CamelCase("AbcDef");
                UtilFramework.Assert(camelCase.TextList[0] == "Abc");
                UtilFramework.Assert(camelCase.TextList[1] == "Def");
            }
            {
                UtilFramework.CamelCase camelCase = new UtilFramework.CamelCase("abcDef");
                UtilFramework.Assert(camelCase.TextList[0] == "abc");
                UtilFramework.Assert(camelCase.TextList[1] == "Def");
            }
            {
                UtilFramework.CamelCase camelCase = new UtilFramework.CamelCase("AbcDefCSharp");
                UtilFramework.Assert(camelCase.TextList[0] == "Abc");
                UtilFramework.Assert(camelCase.TextList[1] == "Def");
                UtilFramework.Assert(camelCase.TextList[2] == "CSharp");
                UtilFramework.Assert(camelCase.EndsWith("DefCSharp"));
                UtilFramework.Assert(camelCase.EndsWith("cDefCSharp") == false);
                UtilFramework.Assert(camelCase.EndsWith("AbcDefCSharp"));
                UtilFramework.Assert(camelCase.EndsWith("AbcDefCSharpCar") == false);
                UtilFramework.Assert(camelCase.EndsWith("CarAbcDefCSharp") == false);
                UtilFramework.Assert(camelCase.EndsWith("") == true);
            }
            {
                UtilFramework.CamelCase camelCase = new UtilFramework.CamelCase("AbcDefCSharp");
                UtilFramework.Assert(camelCase.StartsWith("Abc"));
                UtilFramework.Assert(camelCase.StartsWith("AbcDef"));
                UtilFramework.Assert(camelCase.StartsWith("AbcDefCSharp"));
                UtilFramework.Assert(camelCase.StartsWith("AbcDefCShar") == false);
                UtilFramework.Assert(camelCase.StartsWith("AbcDefCSharpLk") == false);
                UtilFramework.Assert(camelCase.StartsWith("LkAbcDefCSharp") == false);
                UtilFramework.Assert(camelCase.StartsWith(""));
            }
            {
                UtilFramework.CamelCase camelCase = new UtilFramework.CamelCase("ImageFileId");
                UtilFramework.Assert(camelCase.EndsWith("FileId"));
            }
            {
                UtilFramework.CamelCase camelCase = new UtilFramework.CamelCase("ImagEFileId");
                UtilFramework.Assert(camelCase.EndsWith("FileId") == false);
            }
            {
                var source = new AppMain();

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                var dest = (AppMain)UtilJson.Deserialize(jsonSession);
            }
            {
                var source = new MyApp();
                source.Div = new Div(source);
                source.Div.ComponentRemove();

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                var dest = (MyApp)UtilJson.Deserialize(jsonSession);
            }
            {
                var source = new MyApp();
                source.Row = new BootstrapRow(source);
                source.Col = new BootstrapCol((BootstrapRow)source.Row);

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                var dest = (MyApp)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert(!jsonSession.Contains("PropertyReadOnly"));
            }
            {
                var source = new MyApp();

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                var dest = (MyApp)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert(!jsonSession.Contains("PropertyReadOnly"));
            }
            {
                var source = new MyApp();

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                var dest = (MyApp)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert(!jsonSession.Contains("PropertyReadOnly"));
            }
            {
                var source = new MyApp();
                var myGrid = new MyGrid(source)
                {
                    Text = "K7", IsHide = true
                };
                source.MyCell = new MyCell {
                    MyGridBoth = myGrid, MyText = "7755"
                };

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                var dest = (MyApp)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert(UtilFramework.FindCount(jsonClient, "K7") == 1);
                UtilFramework.Assert(UtilFramework.FindCount(jsonSession, "K7") == 1); // Ensure session stores reference
                UtilFramework.Assert(dest.List[0] == dest.MyCell.MyGridBoth);
            }
            {
                var source = new MyApp();
                var myGrid = new MyGrid(source)
                {
                    Text = "K7", IsHide = true
                };
                var myGrid2 = new MyGrid(source)
                {
                    Text = "K8", IsHide = true
                };
                source.MyCell = new MyCell {
                    MyGrid = myGrid, MyGrid2 = myGrid2, MyText = "7755"
                };

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                var dest = (MyApp)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert(jsonClient.Contains("K7"));
                UtilFramework.Assert(!jsonClient.Contains("K8"));
                UtilFramework.Assert(dest.List[1] == dest.MyCell.MyGrid2);
            }
            RunComponentJson();
            {
                A source = new A();
                source.MyEnum = MyEnum.Left;

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                A dest = (A)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert(dest.MyEnum == MyEnum.Left);
                UtilFramework.Assert(dest.MyEnumNullable == null);
            }
            {
                A source = new A();
                source.MyEnumNullable = MyEnum.None;

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                A dest = (A)UtilJson.Deserialize(jsonSession);
                UtilFramework.Assert(dest.MyEnumNullable == MyEnum.None);
            }
            {
                A source = new A();

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                A dest = (A)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert(!jsonSession.Contains(nameof(A.MyEnumList)));
                UtilFramework.Assert(source.MyEnumList == null);
                UtilFramework.Assert(dest.MyEnumList != null);
                UtilFramework.Assert(dest.MyEnumList.Count == 0);
            }
            {
                A source = new A();
                source.MyEnumList = new List <MyEnum>();
                source.MyEnumList.Add(MyEnum.None);
                source.MyEnumList.Add(MyEnum.Left);
                source.MyEnumList.Add(MyEnum.Right);

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                A dest = (A)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert(jsonSession.Contains(nameof(A.MyEnumList)));
                UtilFramework.Assert(dest.MyEnumList[0] == MyEnum.None);
                UtilFramework.Assert(dest.MyEnumList[1] == MyEnum.Left);
                UtilFramework.Assert(dest.MyEnumList[2] == MyEnum.Right);
            }
            {
                A source = new A();
                source.MyEnumNullableList = new List <MyEnum?>();
                source.MyEnumNullableList.Add(MyEnum.None);
                source.MyEnumNullableList.Add(MyEnum.Left);
                source.MyEnumNullableList.Add(null);
                source.MyEnumNullableList.Add(MyEnum.Right);

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                A dest = (A)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert(jsonSession.Contains(nameof(A.MyEnumNullableList)));
                UtilFramework.Assert(dest.MyEnumNullableList[0] == MyEnum.None);
                UtilFramework.Assert(dest.MyEnumNullableList[1] == MyEnum.Left);
                UtilFramework.Assert(dest.MyEnumNullableList[2] == null);
                UtilFramework.Assert(dest.MyEnumNullableList[3] == MyEnum.Right);
            }
            {
                A source = new A();
                source.IntNullableList = new List <int?>();
                source.IntNullableList.Add(0);
                source.IntNullableList.Add(1);
                source.IntNullableList.Add(null);
                source.IntNullableList.Add(2);

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                A dest = (A)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert(jsonSession.Contains(nameof(A.IntNullableList)));
                UtilFramework.Assert(dest.IntNullableList[0] == 0);
                UtilFramework.Assert(dest.IntNullableList[1] == 1);
                UtilFramework.Assert(dest.IntNullableList[2] == null);
                UtilFramework.Assert(dest.IntNullableList[3] == 2);
            }
            {
                A source = new A();
                source.IntList = new List <int>();
                source.IntList.Add(0);
                source.IntList.Add(1);
                source.IntList.Add(2);

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                A dest = (A)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert(jsonSession.Contains(nameof(A.IntList)));
                UtilFramework.Assert(dest.IntList[0] == 0);
                UtilFramework.Assert(dest.IntList[1] == 1);
                UtilFramework.Assert(dest.IntList[2] == 2);
            }
            {
                A source = new A();
                source.V = 33;

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                A dest = (A)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert((int)dest.V == 33);
            }
            {
                A source = new A();
                source.V = "Hello";

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                A dest = (A)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert((string)dest.V == "Hello");
            }
            {
                var date   = DateTime.Now;
                A   source = new A();
                source.Row = new FrameworkDeployDb {
                    Id = 22, FileName = @"C:\Temp\Readme.txt", Date = date
                };

                // Serialize, deserialize
                UtilJson.Serialize(source, out string jsonSession, out string jsonClient);
                A dest = (A)UtilJson.Deserialize(jsonSession);

                UtilFramework.Assert(dest.Row.Id == 22);
                UtilFramework.Assert(dest.Row.FileName == @"C:\Temp\Readme.txt");
                UtilFramework.Assert(dest.Row.Date == date);
            }
            {
                A source = new A();
                source.V = MyEnum.None; // TODO Serialize enum on property of type object.

                // Serialize, deserialize
                // string json = UtilJson.Serialize(source);
                // A dest = (A)UtilJson.Deserialize(json);
            }
        }
        public async Task <TrabalhoListaIdsDto> AtualizarTrabalhosEmLote(IEnumerable <int> ids, bool sobrescreverGatilhoIgnorandoTipo, TrabalhoDefinicaoDto trabalhoDefinicao)
        {
            var trabalhoDefinicaoJson = UtilJson.ConverterApenasCamposNaoNulos(trabalhoDefinicao);

            return(await restService.PostAtualizarTrabalhosEmLoteAsync(ids, sobrescreverGatilhoIgnorandoTipo, trabalhoDefinicaoJson));
        }