using Detached.Annotations;

using Detached.Mappers.EntityFramework;

using Microsoft.Data.Sqlite;

using Microsoft.EntityFrameworkCore;

using Microsoft.Extensions.Logging;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Threading.Tasks;

​

class Program

{

    // this example shows how to use detached to create/update an entity using an anonymous type 

    // as DTO.

    static async Task Main(string[] args)

    {

        Console.WriteLine("- create entity");

        using (DetachedDbContext context = new DetachedDbContext())

        {

            // create the sqlite db.

            context.Database.EnsureCreated();

​

            // add some invoice types. aggregations are top level independent entities, and expected to be there 

            // when the root entity is mapped.

            context.Add(new InvoiceType { Id = 1, Name = "A" });

            context.Add(new InvoiceType { Id = 2, Name = "B" });

            context.SaveChanges();

​

            // import from json.

            // only Id is needed for aggregations

            // undefined properties are not updated.

            string json = @"[{

                'id': 1,

                'invoiceType': { 'id': 2 },

                'rows': [

                    {

                        'description': 'prod 1', 

                        'quantity': 5,

                        'price': 25

                    },

                    {

                        'description': 'prod 2',

                        'quantity': 3,

                        'price': 100

                    }

                ]

            }]".Replace("'", "\"");

​

            // create an invoice by using Map method, passing an anonymous class.

            await context.MapJsonAsync<Invoice>(json);

​

            await context.SaveChangesAsync();

        }

​

        // using is not necessary, but used to simulate different request in a stateless app, like a rest API.

        using (DetachedDbContext context = new DetachedDbContext())

        {

            Invoice persisted = await context.Invoices

                .Where(i => i.Id == 1)

                .Include(i => i.InvoiceType)

                .Include(i => i.Rows)

                .FirstOrDefaultAsync();

​

            // check that all created values are OK.

            Assert(persisted != null, "persisted not null");

            Assert(persisted.InvoiceType != null, "invoice type not null");

            Assert(persisted.InvoiceType.Name == "B", "invoice type is B");

            Assert(persisted.Rows.Count == 2, "row count is 2");

            Assert(persisted.Rows.Any(r => r.Description == "prod 1" && r.Quantity == 5), "row values inserted");

            Assert(persisted.Rows.Any(r => r.Description == "prod 2" && r.Quantity == 3), "row values inserted");

        }

​

        using (DetachedDbContext context = new DetachedDbContext())

        {

            // update from json.

            // undefined properties are not updated!.

            string json = @"[{

                'id': 1,

                'invoiceType': { 'id': 1 }

            }]".Replace("'", "\"");

​

            // create an invoice by using Map method, passing an anonymous class.

            await context.MapJsonAsync<Invoice>(json);

​

            await context.SaveChangesAsync();

        }

​

        // using is not necessary, but used to simulate different request in a stateless app, like a rest API.

        using (DetachedDbContext context = new DetachedDbContext())

        {

            Invoice persisted = await context.Invoices

                .Where(i => i.Id == 1)

                .Include(i => i.InvoiceType)

                .Include(i => i.Rows)

                .FirstOrDefaultAsync();

​

            // check that all created values are OK.

            Assert(persisted != null, "persisted not null");

            Assert(persisted.InvoiceType != null, "invoice type not null");

            Assert(persisted.InvoiceType.Name == "A", "invoice type is A");

            Assert(persisted.Rows.Count == 2, "row count is 2");

            Assert(persisted.Rows.Any(r => r.Description == "prod 1" && r.Quantity == 5), "row values inserted");

            Assert(persisted.Rows.Any(r => r.Description == "prod 2" && r.Quantity == 3), "row values inserted");

        }

​

        Console.WriteLine("[test ended]");

        Console.ReadKey();

    }

​

    static void Assert(bool condition, string label)

    {

        if (condition)

            Console.WriteLine($"{label}: ok");

        else

            Console.WriteLine($"{label}: error!");

    }

}

​

public class DetachedDbContext : DbContext

{

    static SqliteConnection _connection;

    static ILoggerFactory _loggerFactory;

​

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)

    {

        if (_connection == null)

        {

            //_loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());

​

            _connection = new SqliteConnection($"DataSource=file:{Guid.NewGuid()}?mode=memory&cache=shared");

            _connection.Open();

        }

​

        optionsBuilder.UseSqlite(_connection)

                      .UseDetached()

                      .UseLoggerFactory(_loggerFactory);

    }

​

    public DbSet<Invoice> Invoices { get; set; }

}

​

public class Invoice

{

    public virtual int Id { get; set; }

​

    [Aggregation]

    public virtual InvoiceType InvoiceType { get; set; }

​

    [Composition]

    public virtual List<InvoiceRow> Rows { get; set; }

}

​

public class InvoiceType

{

    public virtual int Id { get; set; }

​

    public virtual string Name { get; set; }

}

​

public class InvoiceRow

{

    public virtual int Id { get; set; }

​

    public virtual string Description { get; set; }

​

    public virtual double Quantity { get; set; }

​

    public virtual double Price { get; set; }

}

​