Patrón de repositorio con Entity Framework Core

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

using System;
using System.Linq;
using System.Linq.Expressions;

namespace Domion.Core.Services
{
    /// <summary>
    ///     Query Interface for the EntityManager.
    /// </summary>
    public interface IQueryManager<T> where T : class
    {
        /// <summary>
        ///     Returns an query expression that, when enumerated, will retrieve all objects from the database.
        /// </summary>
        IQueryable<T> Query();

        /// <summary>
        ///     Returns an query expression that, when enumerated, will retrieve all objects from the database that satisfy the where condition.
        /// </summary>
        IQueryable<T> Query(Expression<Func<T, bool>> where);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

namespace Domion.Core.Services
{
    /// <summary>
    ///     DbContext Find Interface
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TKey">Key value(s)</typeparam>
    public interface IEntityManager<T, TKey> where T : class
    {
        /// <summary>
        ///     Finds an entity with the given primary key values.
        ///     If an entity with the given primary key values is being tracked by the context,
        ///     then it is returned immediately without making a request to the database.
        ///     Otherwise, a query is made to the database for an entity with the given primary key values and this entity,
        ///     if found, is attached to the context and returned.
        ///     If no entity is found, then null is returned. (From de official docs)
        /// </summary>
        T Find(TKey key);
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

using Domion.Core.Services;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Linq.Expressions;

namespace Domion.Lib.Data
{
    /// <summary>
    ///     Generic repository implementation.
    /// </summary>
    /// <typeparam name="TEntity">Entity type</typeparam>
    /// <typeparam name="TKey">Key property type</typeparam>
    public abstract class BaseRepository<TEntity, TKey> : IQueryManager<TEntity>, IEntityManager<TEntity, TKey> where TEntity : class
    {
        private readonly DbContext _dbContext;
        private readonly DbSet<TEntity> _dbSet;

        /// <summary>
        ///     Creates the generic repository instance.
        /// </summary>
        /// <param name="dbContext">The DbContext to get the Entity Type from.</param>
        public BaseRepository(DbContext dbContext)
        {
            _dbContext = dbContext;
            _dbSet = _dbContext.Set<TEntity>();
        }

        protected virtual DbContext DbContext => _dbContext;

        /// <summary>
        ///     Detaches the entity from the DbContext's change tracker.
        /// </summary>
        public void Detach(TEntity entity)
        {
            DbContext.Entry(entity).State = EntityState.Detached;
        }

        /// <summary>
        ///     Finds an entity with the given primary key values.
        ///     If an entity with the given primary key values is being tracked by the context,
        ///     then it is returned immediately without making a request to the database.
        ///     Otherwise, a query is made to the database for an entity with the given primary key values and this entity,
        ///     if found, is attached to the context and returned.
        ///     If no entity is found, then null is returned. (From de official docs)
        /// </summary>
        public virtual TEntity Find(TKey key)
        {
            return _dbContext.Find<TEntity>(key);
        }

        /// <summary>
        ///     Returns an entity object with the original values when it was last read from the database.
        ///     Does not include any navigation properties, not even collections.
        /// </summary>
        public virtual TEntity GetOriginalEntity(TEntity entity)
        {
            var entry = DbContext.Entry(entity);

            if (entry == null)
            {
                return null;
            }

            return entry.OriginalValues.ToObject() as TEntity;
        }

        /// <summary>
        ///     Returns an query expression that, when enumerated, will retrieve all objects.
        /// </summary>
        public virtual IQueryable<TEntity> Query()
        {
            return Query(null);
        }

        /// <summary>
        ///     Returns an query expression that, when enumerated, will retrieve only the objects that satisfy the where condition.
        /// </summary>
        public virtual IQueryable<TEntity> Query(Expression<Func<TEntity, bool>> where)
        {
            IQueryable<TEntity> query = _dbSet;

            if (where != null)
            {
                query = query.Where(where);
            }

            return query;
        }

        /// <summary>
        ///     Saves changes from the DbContext's change tracker to the database.
        /// </summary>
        public virtual void SaveChanges()
        {
            _dbContext.SaveChanges();
        }

        /// <summary>
        ///     Marks an entity for deletion in the DbContext's change tracker if it passes the ValidateDelete method.
        /// </summary>
        protected virtual IEnumerable<ValidationResult> TryDelete(TEntity entity)
        {
            var deleteErrors = ValidateDelete(entity);

            if (deleteErrors.Any())
            {
                return deleteErrors;
            }

            _dbSet.Remove(entity);

            return Enumerable.Empty<ValidationResult>();
        }

        /// <summary>
        ///     Adds an entity for insertion in the DbContext's change tracker if it passes the ValidateSave method.
        /// </summary>
        protected virtual IEnumerable<ValidationResult> TryInsert(TEntity entity)
        {
            var saveErrors = ValidateSave(entity);

            if (saveErrors.Any())
            {
                return saveErrors;
            }

            _dbSet.Add(entity);

            return Enumerable.Empty<ValidationResult>();
        }

        /// <summary>
        ///     Marks an entity for update in the DbContext's change tracker if it passes the ValidateSave method.
        /// </summary>
        protected virtual IEnumerable<ValidationResult> TryUpdate(TEntity entity)
        {
            var saveErrors = ValidateSave(entity);

            if (saveErrors.Any())
            {
                return saveErrors;
            }

            _dbSet.Update(entity);

            return Enumerable.Empty<ValidationResult>();
        }

        /// <summary>
        ///     Validates if it's ok to delete the entity from the database.
        /// </summary>
        protected virtual IEnumerable<ValidationResult> ValidateDelete(TEntity model)
        {
            yield break;
        }

        /// <summary>
        ///     Validates if it's ok to save the new or updated entity to the database.
        /// </summary>
        protected virtual IEnumerable<ValidationResult> ValidateSave(TEntity model)
        {
            yield break;
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

using Domion.Core.Services;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Query;
using System;
using System.Linq;
using System.Linq.Expressions;

namespace Domion.Lib.Extensions
{
    /// <summary>
    ///     Extensions for generic IQueryManager < T >.
    /// </summary>
    public static class IQueryManagerExtensions
    {
        /// <summary>
        ///     Returns the first object that satisfies the condition or raises InvalidaOperationException if none.
        /// </summary>
        public static T First<T>(this IQueryManager<T> manager, Expression<Func<T, bool>> where = null) where T : class
        {
            return manager.Query(where).First();
        }

        /// <summary>
        ///     Returns the first object that satisfies the condition or null if none.
        /// </summary>
        public static T FirstOrDefault<T>(this IQueryManager<T> manager, Expression<Func<T, bool>> where = null) where T : class
        {
            return manager.Query(where).FirstOrDefault<T>();
        }

        /// <summary>
        ///     <para>
        ///         Especifies the related objects to include in the query result and returns and IIncludableQueryable that allows chaining of other IQueryable methods.
        ///     </para>
        ///     <para>
        ///         For more information and examples visit:
        ///         https://docs.microsoft.com/en-us/ef/core/api/microsoft.entityframeworkcore.entityframeworkqueryableextensions#Microsoft_EntityFrameworkCore_EntityFrameworkQueryableExtensions_Include__2_System_Linq_IQueryable___0__System_Linq_Expressions_Expression_System_Func___0___1___
        ///     </para>
        /// </summary>
        /// <param name="includeExpression">The navigation property to include</param>
        public static IIncludableQueryable<T, TProperty> Include<T, TProperty>(this IQueryManager<T> manager, Expression<Func<T, TProperty>> includeExpression) where T : class
        {
            return manager.Query().Include(includeExpression);
        }

        /// <summary>
        ///     Returns the single object that satisfies the condition or raises InvalidaOperationException if none or more than one.
        /// </summary>
        public static T Single<T>(this IQueryManager<T> manager, Expression<Func<T, bool>> where = null) where T : class
        {
            return manager.Query(where).Single<T>();
        }

        /// <summary>
        ///     Returns the single object that satisfies the condition or null if none or raises InvalidaOperationException if more than one.
        /// </summary>
        public static T SingleOrDefault<T>(this IQueryManager<T> manager, Expression<Func<T, bool>> where = null) where T : class
        {
            return manager.Query(where).SingleOrDefault<T>();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace Domion.Lib.Data
{
    // As suggested in: https://github.com/aspnet/EntityFramework/issues/2805

    public abstract class EntityTypeConfiguration<TEntity>
        where TEntity : class
    {
        public abstract void Map(EntityTypeBuilder<TEntity> builder);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

using Microsoft.EntityFrameworkCore;

namespace Domion.Lib.Data
{
    // As suggested in: https://github.com/aspnet/EntityFramework/issues/2805

    public static class ModelBuilderExtensions
    {
        public static void AddConfiguration<TEntity>(this ModelBuilder modelBuilder, EntityTypeConfiguration<TEntity> configuration)
            where TEntity : class
        {
            configuration.Map(modelBuilder.Entity<TEntity>());
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

//------------------------------------------------------------------------------
//  BudgetClass.cs
//
//  Implementation of: BudgetClass (Class) <<ef-entity>>
//  Generated by Domion-MDA - http://www.coderepo.blog/domion
//
//  Created on     : 02-jun-2017 10:49:07
//  Original author: Miguel
//------------------------------------------------------------------------------

using System;
using System.ComponentModel.DataAnnotations;

namespace DFlow.Budget.Core.Model
{
    public class BudgetClass
    {
        public BudgetClass()
        {
            TransactionType = TransactionType.Income;
        }

        public int Id { get; set; }

        [Required]
        [MaxLength(100)]
        public virtual string Name { get; set; } // Key data ----------

        public virtual int Order { get; set; }

        public virtual Byte[] RowVersion { get; set; }

        public virtual TransactionType TransactionType { get; set; }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

//------------------------------------------------------------------------------
//  TransactionType.cs
//
//  Implementation of: TransactionType (Enumeration) <<enumeration>>
//  Generated by Domion-MDA - http://www.coderepo.blog/domion
//
//  Created on     : 02-jun-2017 10:49:11
//  Original author: Miguel
//------------------------------------------------------------------------------

namespace DFlow.Budget.Core.Model
{
    public enum TransactionType
    {
        Income,
        Expense,
        Loan,
        Savings,
        Investment,
        Tax
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

//------------------------------------------------------------------------------
//  IBudgetClassManager.cs
//
//  Implementation of: IBudgetClassManager (Interface) <<entity-manager>>
//  Generated by Domion-MDA - http://www.coderepo.blog/domion
//
//  Created on     : 02-jun-2017 10:49:09
//  Original author: Miguel
//------------------------------------------------------------------------------

using DFlow.Budget.Core.Model;
using Domion.Core.Services;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace DFlow.Budget.Core.Services
{
    public interface IBudgetClassManager : IQueryManager<BudgetClass>, IEntityManager<BudgetClass, int>
    {
        /// <summary>
        ///     <para>
        ///         Refreshes the entity in the DbContext's change tracker, requerying the database.
        ///     </para>
        ///     <para>
        ///         Important, this only refreshes the passed entity. It does not refresh the related entities
        ///         (navigation or collection properties). If needed yo have to modify this method and call the
        ///         method on each one.
        ///     </para>
        /// </summary>
        BudgetClass Refresh(BudgetClass entity);

        /// <summary>
        ///     Saves changes from the DbContext's change tracker to the database.
        /// </summary>
        void SaveChanges();

        /// <summary>
        ///     Marks an entity for deletion in the DbContext's change tracker if no errors are found in the ValidateDelete method.
        /// </summary>
        IEnumerable<ValidationResult> TryDelete(BudgetClass entity);

        /// <summary>
        ///     Adds an entity for insertion in the DbContext's change tracker if no errors are found in the ValidateSave method.
        ///     This method also checks that the concurrency token (RowVersion) is EMPTY.
        /// </summary>
        IEnumerable<ValidationResult> TryInsert(BudgetClass entity);

        /// <summary>
        ///     Marks an entity for update in the DbContext's change tracker if no errors are found in the ValidateSave method.
        ///     This method also checks that the concurrency token (RowVersion) is NOT EMPTY.
        /// </summary>
        IEnumerable<ValidationResult> TryUpdate(BudgetClass entity);

        /// <summary>
        ///     Calls TryInsert or TryUpdate accordingly, based on the value of the Id property;
        /// </summary>
        IEnumerable<ValidationResult> TryUpsert(BudgetClass entity);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

//------------------------------------------------------------------------------
//  BudgetClassConfiguration.cs
//
//  Implementation of: BudgetClassConfiguration (Class) <<entity-configuration>>
//  Generated by Domion-MDA - http://www.coderepo.blog/domion
//
//  Created on     : 02-jun-2017 10:49:07
//  Original author: Miguel
//------------------------------------------------------------------------------

using DFlow.Budget.Core.Model;
using Domion.Lib.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace DFlow.Budget.Lib.Data
{
    public class BudgetClassConfiguration : EntityTypeConfiguration<BudgetClass>
    {
        public override void Map(EntityTypeBuilder<BudgetClass> builder)
        {
            builder.ToTable("BudgetClasses", schema: "Budget");

            builder.HasKey(bc => bc.Id);

            builder.Property(bc => bc.RowVersion)
                .IsRowVersion();

            builder.HasIndex(bc => bc.Name)
                .IsUnique();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

//------------------------------------------------------------------------------
//  BudgetDbContext.cs
//
//  Implementation of: BudgetDbContext (Class) <<dbcontext>>
//  Generated by Domion-MDA - http://www.coderepo.blog/domion
//
//  Created on     : 02-jun-2017 10:49:08
//  Original author: Miguel
//------------------------------------------------------------------------------

using DFlow.Budget.Core.Model;
using Domion.Lib.Data;
using Microsoft.EntityFrameworkCore;
using NLog;
using System;

namespace DFlow.Budget.Lib.Data
{
    public class BudgetDbContext : DbContext
    {
        private static Logger logger = LogManager.GetCurrentClassLogger();

        public BudgetDbContext()
            : base()
        {
        }

        public BudgetDbContext(DbContextOptions<BudgetDbContext> options)
            : base(options)
        {
        }

        public virtual DbSet<BudgetClass> BudgetClasses { get; set; }

        public override int SaveChanges()
        {
            try
            {
                return base.SaveChanges();
            }
            catch (Exception ex)
            {
                logger.Error(ex);

                throw;
            }
        }

        ///
        /// <param name="modelBuilder"></param>
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            ConfigureLocalModel(modelBuilder);

            ConfigureExternalModel(modelBuilder);
        }

        ///
        /// <param name="modelBuilder"></param>
        private void ConfigureExternalModel(ModelBuilder modelBuilder)
        {
        }

        ///
        /// <param name="modelBuilder"></param>
        private void ConfigureLocalModel(ModelBuilder modelBuilder)
        {
            // Database schema is "Budget"

            modelBuilder.AddConfiguration(new BudgetClassConfiguration());
        }
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//------------------------------------------------------------------------------
//  BudgetClassManager.cs
//
//  Implementation of: BudgetClassManager (Class) <<entity-manager>>
//  Generated by Domion-MDA - http://www.coderepo.blog/domion
//
//  Created on     : 02-jun-2017 10:49:07
//  Original author: Miguel
//------------------------------------------------------------------------------

using DFlow.Budget.Core.Model;
using DFlow.Budget.Core.Services;
using DFlow.Budget.Lib.Data;
using Domion.Core.Services;
using Domion.Lib.Data;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Linq.Expressions;

namespace DFlow.Budget.Lib.Services
{
    public class BudgetClassManager : BaseRepository<BudgetClass, int>, IQueryManager<BudgetClass>, IEntityManager<BudgetClass, int>, IBudgetClassManager
    {
        public static string duplicateByNameError = @"There's another BudgetClass with Name ""{0}"", can't duplicate! (Id={1})";

        /// <summary>
        ///     Entity manager for BudgetClass
        /// </summary>
        public BudgetClassManager(BudgetDbContext dbContext)
            : base(dbContext)
        {
        }

        /// <summary>
        ///     Returns another BudgetClass with the same Name if it exists or null if doesn't.
        /// </summary>
        public BudgetClass FindDuplicateByName(BudgetClass entity)
        {
            if (entity.Id == 0)
            {
                return Query(bc => bc.Name == entity.Name.Trim()).SingleOrDefault();
            }
            else
            {
                return Query(bc => bc.Name == entity.Name.Trim() && bc.Id != entity.Id).SingleOrDefault();
            }
        }

        /// <summary>
        ///     Returns an IQueryable that, when enumerated, will retrieve the objects that satisfy the where condition
        ///     or all of them if where condition is null.
        /// </summary>
        public override IQueryable<BudgetClass> Query(Expression<Func<BudgetClass, bool>> where = null)
        {
            return base.Query(where);
        }

        /// <summary>
        ///     <para>
        ///         Refreshes the entity in the DbContext's change tracker, requerying the database.
        ///     </para>
        ///     <para>
        ///         Important, this only refreshes the passed entity. It does not refresh the related entities
        ///         (navigation or collection properties). If needed yo have to modify this method and call the
        ///         method on each one.
        ///     </para>
        /// </summary>
        public virtual BudgetClass Refresh(BudgetClass entity)
        {
            base.Detach(entity);

            return Find(entity.Id);
        }

        /// <summary>
        ///     Marks an entity for deletion in the DbContext's change tracker if no errors are found in the ValidateDelete method.
        /// </summary>
        public new virtual IEnumerable<ValidationResult> TryDelete(BudgetClass entity)
        {
            return base.TryDelete(entity);
        }

        /// <summary>
        ///     Adds an entity for insertion in the DbContext's change tracker if no errors are found in the ValidateSave method.
        ///     This method also checks that the concurrency token (RowVersion) is EMPTY.
        /// </summary>
        public new virtual IEnumerable<ValidationResult> TryInsert(BudgetClass entity)
        {
            if (entity.RowVersion != null && entity.RowVersion.Length > 0) throw new InvalidOperationException("RowVersion not empty on Insert");

            CommonSaveOperations(entity);

            return base.TryInsert(entity);
        }

        /// <summary>
        ///     Marks an entity for update in the DbContext's change tracker if no errors are found in the ValidateSave method.
        ///     This method also checks that the concurrency token (RowVersion) is NOT EMPTY.
        /// </summary>
        public new virtual IEnumerable<ValidationResult> TryUpdate(BudgetClass entity)
        {
            if (entity.RowVersion == null || entity.RowVersion.Length == 0) throw new InvalidOperationException("RowVersion empty on Update");

            CommonSaveOperations(entity);

            return base.TryUpdate(entity);
        }

        /// <summary>
        ///     Calls TryInsert or TryUpdate accordingly, based on the value of the Id property;
        /// </summary>
        public virtual IEnumerable<ValidationResult> TryUpsert(BudgetClass entity)
        {
            if (entity.Id == 0)
            {
                return TryInsert(entity);
            }
            else
            {
                return TryUpdate(entity);
            }
        }

        /// <summary>
        ///     Performs operations that have to be executed both on inserts and updates.
        /// </summary>
        internal virtual void CommonSaveOperations(BudgetClass entity)
        {
            TrimStrings(entity);
        }

        /// <summary>
        ///     Returns the validation results for conditions that prevent the entity to be removed.
        /// </summary>
        protected override IEnumerable<ValidationResult> ValidateDelete(BudgetClass entity)
        {
            yield break;
        }

        /// <summary>
        ///     Returns the validation results for conditions that prevent the entity to be added or updated.
        /// </summary>
        protected override IEnumerable<ValidationResult> ValidateSave(BudgetClass entity)
        {
            BudgetClass duplicateByName = FindDuplicateByName(entity);

            if (duplicateByName != null)
            {
                yield return new ValidationResult(string.Format(duplicateByNameError, duplicateByName.Name, duplicateByName.Id), new[] { "Name" });
            }

            yield break;
        }

        private void TrimStrings(BudgetClass entity)
        {
            if (entity.Name != null) entity.Name = entity.Name.Trim();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

using DFlow.Budget.Lib.Data;
using Microsoft.EntityFrameworkCore;
using System;

namespace DFlow.Budget.Setup
{
    public class BudgetDbSetupHelper
    {
        private string _connectionString;
        private DbContextOptions<BudgetDbContext> _options;

        public BudgetDbSetupHelper(string connectionString)
        {
            _connectionString = connectionString;
        }

        /// <summary>
        /// Returns the DbContext if the database has been set up.
        /// </summary>
        /// <returns></returns>
        public BudgetDbContext GetDbContext()
        {
            if (_options == null) throw new InvalidOperationException($"Must run {nameof(BudgetDbSetupHelper)}.{nameof(SetupDatabase)} first!");

            return new BudgetDbContext(_options);
        }

        /// <summary>
        /// Creates the database and applies pending migrations.
        /// </summary>
        public void SetupDatabase()
        {
            var optionBuilder = new DbContextOptionsBuilder<BudgetDbContext>();

            optionBuilder.UseSqlServer(_connectionString);

            _options = optionBuilder.Options;

            using (var dbContext = GetDbContext())
            {
                dbContext.Database.Migrate();
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Metadata;

namespace DFlow.Budget.Lib.Migrations
{
    public partial class CreateMigration_BudgetDbContext : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.EnsureSchema(
                name: "Budget");

            migrationBuilder.CreateTable(
                name: "BudgetClasses",
                schema: "Budget",
                columns: table => new
                {
                    Id = table.Column<int>(nullable: false)
                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
                    Name = table.Column<string>(maxLength: 100, nullable: false),
                    Order = table.Column<int>(nullable: false),
                    RowVersion = table.Column<byte[]>(rowVersion: true, nullable: true),
                    TransactionType = table.Column<int>(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_BudgetClasses", x => x.Id);
                });

            migrationBuilder.CreateIndex(
                name: "IX_BudgetClasses_Name",
                schema: "Budget",
                table: "BudgetClasses",
                column: "Name",
                unique: true);
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "BudgetClasses",
                schema: "Budget");
        }
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

using DFlow.Budget.Core.Model;
using DFlow.Budget.Lib.Services;
using DFlow.Budget.Setup;
using Domion.Lib.Extensions;
using System;
using System.Linq;
using System.Text;

namespace DFlow.CLI
{
    internal class Program
    {
        private static BudgetClass[] _dataSet = new BudgetClass[]
        {
            new BudgetClass { Name = "Income", Order = 1, TransactionType = TransactionType.Income },
            new BudgetClass { Name = "Expenses", Order = 2, TransactionType = TransactionType.Expense },
            new BudgetClass { Name = "Investments", Order = 3, TransactionType = TransactionType.Investment },
        };

        private static BudgetDbSetupHelper _dbHelper;

        private static void LoadSeedData()
        {
            Console.WriteLine("Seeding data...\n");

            using (var dbContext = _dbHelper.GetDbContext())
            {
                var manager = new BudgetClassManager(dbContext);

                foreach (var item in _dataSet)
                {
                    var entity = manager.SingleOrDefault(bc => bc.Name.StartsWith(item.Name));

                    if (entity == null)
                    {
                        manager.TryInsert(item);
                    }
                    else
                    {
                        var tokens = entity.Name.Split('-');

                        if (tokens.Length == 1)
                        {
                            entity.Name += " - 1";
                        }
                        else
                        {
                            entity.Name = tokens[0].Trim() + $" - {int.Parse(tokens[1]) + 1}";
                        }
                    }
                }

                manager.SaveChanges();
            }
        }

        private static void Main(string[] args)
        {
            Console.OutputEncoding = Encoding.UTF8;

            Console.WriteLine("EF Core App\n");

            SetupDb();

            LoadSeedData();

            PrintDb();

            Console.WriteLine("Press any key to continue...");

            Console.ReadKey();
        }

        private static void PrintDb()
        {
            using (var dbContext = _dbHelper.GetDbContext())
            {
                Console.WriteLine("Printing data...\n");

                Console.WriteLine("Budget Classes");
                Console.WriteLine("--------------");

                int nameLength = _dataSet.Select(c => c.Name.Length).Max() + 5;
                int typeLength = _dataSet.Select(c => c.TransactionType.ToString().Length).Max();

                foreach (var item in dbContext.BudgetClasses)
                {
                    Console.WriteLine($"| {item.Name.PadRight(nameLength)} | {item.Order} | {item.TransactionType.ToString().PadRight(typeLength)} |");
                }

                Console.WriteLine();
            }
        }

        private static void SetupDb()
        {
            string connectionString = "Data Source=localhost;Initial Catalog=DFlow.CLI;Integrated Security=SSPI;MultipleActiveResultSets=true";

            Console.WriteLine($"Setting up database\n ({connectionString})...\n");

            _dbHelper = new BudgetDbSetupHelper(connectionString);

            _dbHelper.SetupDatabase();
        }
    }
}