Пример #1
0
        static void Main(string[] arguments)
        {
            var conf = new HlidacStatu.Api.V2.CoreApi.Client.Configuration();

            conf.AddDefaultHeader("Authorization", System.Configuration.ConfigurationManager.AppSettings["apikey"]);
            conf.Timeout = 180 * 1000;

            api2 = HlidacStatu.Api.V2.Dataset.Typed.Dataset <record> .OpenDataset(System.Configuration.ConfigurationManager.AppSettings["apikey"], DataSetId);

            args = new Devmasters.Args(arguments, new string[] { "/mp3path" });
            logger.Info("Starting with params" + string.Join(" ", args.Arguments));


            //create dataset

            if (!args.MandatoryPresent())
            {
                Help(); return;
            }

            string osobaId = args["/osobaid"];

            string playlist = args["/playlist"];

            int threads = args.GetNumber("/t") ?? 5;

            int max = args.GetNumber("/max") ?? 300;


            string[] vids = args.GetArray("/ids");

            string mp3path = args["/mp3path"];


            HttpClient httpClient = new HttpClient();

            httpClient.DefaultRequestHeaders.Add("Authorization", System.Configuration.ConfigurationManager.AppSettings["apikey"]);

            var jsonResult = httpClient.GetStringAsync("https://www.hlidacstatu.cz/api/v2/osoby/social?typ=Youtube")
                             .Result;
            var osoby = Newtonsoft.Json.JsonConvert.DeserializeObject <osoba[]>(jsonResult);

            foreach (var o in osoby)
            {
                foreach (var url in o.SocialniSite)
                {
                    if (string.IsNullOrEmpty(osobaId))
                    {
                        Process(o, url.Url, threads, max, vids, mp3path);
                    }
                    else if (o.NameId == osobaId)
                    {
                        Process(o, url.Url, threads, max, vids, mp3path);
                    }
                }
            }
        }
Пример #2
0
        static void Main(string[] _args)
        {
            Console.WriteLine("Rozhodnuti-UOHS \n");
            Devmasters.Args args = new Devmasters.Args(_args, new[] { "/apiKey" });
            logger.Info("Starting with params" + string.Join(" ", args.Arguments));

            if (args.MandatoryPresent() == false)
            {
                Console.WriteLine("/apikey=xxx [/start=]  [/new] [/num=]");
                return;
            }
            debug = args.Exists("/debug");

            InitDS(args.Exists("/new"), args["/apiKey"]);

            httpClient = new HttpClient();
            httpClient.DefaultRequestHeaders.Add("Authorization", args["/apiKey"]);


            //check last Rozhodnuti
            var res    = ds.Search("", 1, "DbCreated", true);
            int lastId = 0;

            if (res.Total > 0)
            {
                lastId = Convert.ToInt32(res.Results.First().Id);
            }

            int num   = args.GetNumber("/num", 1500).Value;
            var start = args.GetNumber("/start", 1500);

            if (start.HasValue)
            {
                lastId = start.Value;
            }

            if (lastId == 0)
            {
                num = 90000;
            }


            ParsePages(datasetId, lastId, num); //stahnuti, parsovani dat z UOHS a vlozeni do Datasetu
        }
Пример #3
0
        static void Main(string[] parameters)
        {
            var args = new Devmasters.Args(parameters);

            logger.Info($"Starting with args {string.Join(' ',parameters)}");

            apiKey = args["/apikey"];
            force  = args.Exists("/force");

            var jsonGen = new JSchemaGenerator
            {
                DefaultRequired = Required.Default
            };
            var genJsonSchema = jsonGen.Generate(typeof(majitele)).ToString();

            HlidacStatu.Api.V2.CoreApi.Model.Registration reg = new HlidacStatu.Api.V2.CoreApi.Model.Registration(
                "Skuteční majitelé firem", DatasetNameId,
                "https://esm.justice.cz/",
                "https://github.com/HlidacStatu/Datasety/tree/master/SkutecniMajitele",
                "Evidence skutečných majitelů firem podle zákona č. 37/2021 Sb.",
                genJsonSchema, betaversion: true, allowWriteAccess: false,
                orderList: new string[, ] {
                { "Podle datumu zápisu", "datum_zapis" },
                { "Podle IČ subjektu", "ico" },
            },
                defaultOrderBy: "datum_zapis desc",

                searchResultTemplate: new HlidacStatu.Api.V2.CoreApi.Model.Template()
            {
                Body = @"
<!-- scriban {{ date.now }} --> 
<table class=""table table-hover"">
                        <thead>
                            <tr>
<th>Detail</th>
<th>Subjekt</th>
<th>Skutečný majitel</th>
</tr>
                        </thead>
                        <tbody>
{{ for item in model.Result }}
<tr>
<td ><a href=""{{ fn_DatasetItemUrl item.id }}"">{{item.id}}</a></td>
<td >{{fn_RenderCompanyWithLink item.ico}}</td>
<td >
{{ for sk in item.skutecni_majitele }}

    {{ if !(fn_IsNullOrEmpty sk.osobaId) }}
      {{fn_RenderPersonWithLink2 sk.osobaId}},
    {{else }}
      {{sk.osoba_jmeno}} {{sk.osoba_prijmeni}},

    {{ end }}
{{end }}
</td>
</tr>
{{ end }}

</tbody></table>
"
            },
                detailTemplate: new HlidacStatu.Api.V2.CoreApi.Model.Template()
            {
                Body = @"
<!-- scriban {{ date.now }} --> 
 {{this.item = model}}
<table class=""table table-hover""><tbody>
<tr><td>IČ</td><td ><a href=""{{ fn_DatasetItemUrl item.id }}"">{{item.id}}</a></td></tr>
<tr><td>Subjekt</td><td >{{fn_RenderCompanyWithLink item.ico}}<br/>
{{fn_RenderCompanyInformations item.ico 3}}</td></tr>
<tr><td>Skutečný majitel</td><td >
{{ for sk in item.skutecni_majitele }}
    <dl>
      <dt>
    {{ if !(fn_IsNullOrEmpty sk.osobaId) }}
      {{fn_RenderPersonWithLink2 sk.osobaId}}
    {{else }}
      {{sk.osoba_jmeno}} {{sk.osoba_prijmeni}}
    {{end}}

    ({{sk.udaj_typ_nazev}}) 
      </dt>
      <dd>
      {{if !(fn_IsNullOrEmpty sk.podil_na_prospechu_hodnota) }}
         Podíl na prospěchu ze společnosti: {{sk.podil_na_prospechu_hodnota}} 
         {{if sk.podil_na_prospechu_typ==""PROCENTA""}}%{{else}}({{sk.podil_na_prospechu_typ}}){{end}}
<br/>
      {{end}}
      {{if !(fn_IsNullOrEmpty sk.podil_na_hlasovani_hodnota) }}
         Podíl na hlasovacích právech: {{sk.podil_na_hlasovani_hodnota}} 
         {{if sk.podil_na_hlasovani_typ==""PROCENTA""}}%{{else}}({{sk.podil_na_hlasovani_typ}}){{end}}

<br/>
      {{end}}
      </dd>
    </dl>
{{end }}
</td></tr>
</table>

"
            }

                );


            try
            {
                if (args.Exists("/new"))
                {
                    Configuration configuration = new Configuration();
                    configuration.AddDefaultHeader("Authorization", apiKey);
                    HlidacStatu.Api.V2.CoreApi.DatasetyApi datasetyApi = new HlidacStatu.Api.V2.CoreApi.DatasetyApi(configuration);
                    datasetyApi.ApiV2DatasetyDelete(reg.DatasetId);
                }
                ds = HlidacStatu.Api.V2.Dataset.Typed.Dataset <majitele> .OpenDataset(apiKey, DatasetNameId);
            }
            catch (HlidacStatu.Api.V2.CoreApi.Client.ApiException e)
            {
                ds = HlidacStatu.Api.V2.Dataset.Typed.Dataset <majitele> .CreateDataset(apiKey, reg);
            }
            catch (Exception e)
            {
                throw;
            }
            var wc = new System.Net.WebClient();

            var package_list = Newtonsoft.Json.Linq.JObject.Parse(
                wc.DownloadString("https://dataor.justice.cz/api/3/action/package_list")
                );

            var onlyCurrYears = package_list["result"]
                                .ToArray()
                                .Select(m => m.Value <string>())
                                .Where(m => m.EndsWith($"-{DateTime.Now.Year}") && m.Contains("-full-"))
                                //.Where(m => m == "as-full-ostrava-2021") //DEBUG
            ;

            Devmasters.Batch.Manager.DoActionForAll <string>(onlyCurrYears,
                                                             name =>
            {
                ProcessXML(args, name);

                return(new Devmasters.Batch.ActionOutputData());
            }, Devmasters.Batch.Manager.DefaultOutputWriter, Devmasters.Batch.Manager.DefaultProgressWriter,
                                                             !System.Diagnostics.Debugger.IsAttached,
                                                             maxDegreeOfParallelism: 2, prefix: "Get XMLS ");
        }
Пример #4
0
        private void Log()
        {
            Devmasters.Logging.LogMessage msg = null;
            if (this.ExactElapsedMiliseconds > slowLoggerThreshold)
            {
                if (context != null)
                {
                    if (context.Request != null)
                    {
                        msg = new Devmasters.Logging.LogMessage();
                        //<conversionPattern value="%date|%property{page}|%property{params}|%property{user}|%property{elapsedtime}" />
                        msg.SetCustomKeyValue("web_page", context.Request.Url.AbsolutePath);
                        msg.SetCustomKeyValue("web_params", FormatParams(context));
                        msg.SetCustomKeyValue("web_elapsedtime", this.ExactElapsedMiliseconds);

                        if (context.User != null && context.User.Identity != null && context.User.Identity.Name != null)
                        {
                            msg.SetCustomKeyValue("web_user", context.User.Identity.Name);
                        }
                    }
                }
                else
                {
                    if (this.IsRunning || this.ElapsedTicks == 0)
                    {
                        return;
                    }

                    if (
                        (level != Devmasters.Logging.PriorityLevel.Fatal | level != Devmasters.Logging.PriorityLevel.Error) &&
                        this.ExactElapsedMiliseconds > slowLoggerThreshold && slowLoggerThreshold > 0)
                    {
                        logger.Error(string.Format(textTemplate + " TOO SLOW", this.ExactElapsedMiliseconds));
                    }
                }

                switch (level)
                {
                case Devmasters.Logging.PriorityLevel.Debug:
                    if (msg != null)
                    {
                        logger.Debug(msg);
                    }
                    else
                    {
                        logger.Debug(string.Format(textTemplate, this.ExactElapsedMiliseconds));
                    }
                    break;

                case Devmasters.Logging.PriorityLevel.Information:
                    if (msg != null)
                    {
                        logger.Info(msg);
                    }
                    else
                    {
                        logger.Info(string.Format(textTemplate, this.ExactElapsedMiliseconds));
                    }
                    break;

                case Devmasters.Logging.PriorityLevel.Warning:
                    if (msg != null)
                    {
                        logger.Warning(msg);
                    }
                    else
                    {
                        logger.Warning(string.Format(textTemplate, this.ExactElapsedMiliseconds));
                    }
                    break;

                case Devmasters.Logging.PriorityLevel.Error:
                    if (msg != null)
                    {
                        logger.Error(msg);
                    }
                    else
                    {
                        logger.Error(string.Format(textTemplate, this.ExactElapsedMiliseconds));
                    }
                    break;

                case Devmasters.Logging.PriorityLevel.Fatal:
                    if (msg != null)
                    {
                        logger.Fatal(msg);
                    }
                    else
                    {
                        logger.Fatal(string.Format(textTemplate, this.ExactElapsedMiliseconds));
                    }
                    break;
                }
            }
        }