using System;

using Humanizer; // Libreria de tercero

using System.Threading;

using System.Threading.Tasks;

using System.Globalization;

using Serilog; // Libreria de tercero

using CsvHelper; //Libreria de tercero

using System.IO;

using System.Net.Http;

using AutoMapper;

using CsvHelper.Configuration; 

using System.Collections.Generic;

using System.Linq;

using Hangfire; //Libreria de tercero

using Quartz; //Libreria de tercero

using Quartz.Impl; //Libreria de tercero

​

public class Program

{

​

    public static void Main()

    {

        Thread.CurrentThread.CurrentUICulture = new CultureInfo("es-ES");

        //Console.WriteLine(DateTime.UtcNow.AddDays(1).Humanize ().Transform(To.TitleCase));

​

        // Later in a different part of your code.

        StreamReader reader = new StreamReader(ExternalCSV.CreateAsync().Result.CSV);

        //string text = reader.ReadToEnd();

        //Console.WriteLine(text);

​

        var csvConfig = new CsvConfiguration(CultureInfo.InvariantCulture)

        {

            //HasHeaderRecord = false,

            //Comment = '#',

            //AllowComments = true,

            //Delimiter = ";",

        };

​

        List<Person> lstPerson = new List<Person>();

        using (var csvReader = new CsvReader(reader, csvConfig))

        {       

            while (csvReader.Read())

            {

                Person person = new Person()

                {

                    Index = csvReader.GetField(0),

                    UserId = csvReader.GetField(1),

                    FirstName = csvReader.GetField(2),

                    LastName = csvReader.GetField(3),

                    Sex = csvReader.GetField(4),

                    Email = csvReader.GetField(5),

                    Phone = csvReader.GetField(6),

                    DateOfbirth = csvReader.GetField(7),

                    JobTitle = csvReader.GetField(8)

                };

                lstPerson.Add(person);

            }

        }

​

        foreach(Person person in lstPerson.Where(p => p.Sex == "Male").Take(3))

        {

            Console.WriteLine($"{person.FirstName} {person.LastName} is {person.JobTitle}");

        }

​

    }

​

    // ScheduledTasks

​

    // Quartz

    // https://jmunoadotnet.wordpress.com/2016/12/20/programando-trabajos-con-quartz-net/

}

​

public class Person

{

    public string Index { get; set; }

    public string UserId  { get; set; }

    public string FirstName { get; set; }

    public string LastName { get; set; }

    public string Sex { get; set; }

    public string Email { get; set; }

    public string Phone { get; set; }

    public string DateOfbirth { get; set; }

    public string JobTitle { get; set; }

}

​

public class ExternalCSV

{

​

    private Stream _csv;

​

    public Stream CSV

    {

        get { return _csv; }

        private set { _csv = value; }

    }

​

    // make sure no one but the Create function can call the constructor:

    private ExternalCSV() { }

​

    public static async Task<ExternalCSV> CreateAsync()

    {

        ExternalCSV newInstanceExternalIP = new ExternalCSV();

        await newInstanceExternalIP.InitializeAsync();

        return newInstanceExternalIP;

    }

​

    private async Task InitializeAsync() => _csv = await GetExternalCSVAsync();

​

    public override string ToString()

    {

        StreamReader reader = new StreamReader(_csv);

        return reader.ReadToEnd();

    }

​

    //https://www.datablist.com/learn/csv/download-sample-csv-files

    private static async Task<Stream> GetExternalCSVAsync()

    {

        HttpClient client = new HttpClient();

        HttpResponseMessage response = await client.GetAsync

            (

            "https://media.githubusercontent.com/media/datablist/sample-csv-files/main/files/people/people-100.csv"

        );

        MyJobs job = new MyJobs();

        await job.Hola();

        //Thread.Sleep(TimeSpan.FromSeconds(60));

        response.EnsureSuccessStatusCode();

        return (await response.Content.ReadAsStreamAsync());

    }

​

}

​

///////////////////////////////////////

public class MyJobs : IJob

{

    /// <summary>

    /// using quartz for periodic publishing.

    /// </summary>

    /// <param name="context">quartz' execution context.</param>

    public async Task Execute(IJobExecutionContext context)

    {

        // Según el job que se vaya a ejecutar

        switch (context.JobDetail.Key.ToString())

        {

            case "app.arranqueApp":

                Console.WriteLine(string.Format("[{0}]: Aplicación iniciada!", DateTime.Now));

                break;

            case "app.cada24h":

                Console.WriteLine(string.Format("[{0}]: Hora de comer!", DateTime.Now));

                break;

            case "app.cada10s":

                Console.WriteLine(string.Format("[{0}]: La app esta UP!.", DateTime.Now));

                break;

        }

    }

    public async Task Hola()

    {

         try

         {

                // Creamos el demonio

                IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();

​

                // Iniciamos el demonio

                await scheduler.Start();

​

                // Definimos un trabajo y lo asociamos a la clase MyJobs

                IJobDetail appStartJob = JobBuilder.Create<MyJobs>()

                    .WithIdentity("arranqueApp", "app")

                    .Build();

​

                // Lanzamos el job cada vez que arranquemos la aplicación

                ITrigger appStartTrigger = TriggerBuilder.Create()

                    .WithIdentity("arranqueApp", "app")

                    .StartNow()

                    .Build();

​

                // Asociamos el job y el trigger al demonio

                await scheduler.ScheduleJob(appStartJob, appStartTrigger);

​

                // Definimos un trabajo y lo asociamos a la clase MyJobs

                IJobDetail every24hJob = JobBuilder.Create<MyJobs>()

                    .WithIdentity("cada24h", "app")

                    .Build();

​

                // Lanzamos el job todos los días a las 14:00:00

                ITrigger every24hTrigger = TriggerBuilder.Create()

                    .WithIdentity("cada24h", "app")

                    .StartAt(DateBuilder.DateOf(14, 00, 0)) //14:00:00

                    .WithSimpleSchedule(s => s

                        .WithIntervalInHours(24)

                        .RepeatForever())

                    .Build();

​

                // Asociamos el job y el trigger al demonio

                await scheduler.ScheduleJob(every24hJob, every24hTrigger);

​

                // Definimos un trabajo y lo asociamos a la clase MyJobs

                IJobDetail every10sJob = JobBuilder.Create<MyJobs>()

                    .WithIdentity("cada10s", "app")

                    .Build();

​

                // Lanzamos el job cada 10 segundos

                ITrigger every10sTrigger = TriggerBuilder.Create()

                    .WithIdentity("cada10s", "app")

                    .StartNow()

                    .WithSimpleSchedule(s => s

                        .WithIntervalInSeconds(10)

                        .RepeatForever())

                    .Build();

​

                // Asociamos el job y el trigger al demonio

                await scheduler.ScheduleJob(every10sJob, every10sTrigger);

            }

            catch (SchedulerException se)

            {

                Console.WriteLine(se);

            }

    }

}

​

​